i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated libpng to 1.2.37

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@31290 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Jérôme Duval
2009-06-28 13:46:52 +00:00
parent 590a78c63a
commit c1094043c9
17 changed files with 1786 additions and 1385 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/libs/png/png.h
+86 -67
View File
@@ -1,6 +1,6 @@
/* png.h - header file for PNG reference library /* png.h - header file for PNG reference library
* *
* libpng version 1.2.35 - February 14, 2009 * libpng version 1.2.37 - June 4, 2009
* Copyright (c) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -8,7 +8,7 @@
* Authors and maintainers: * Authors and maintainers:
* libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
* libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.2.35 - February 14, 2009: Glenn * libpng versions 0.97, January 1998, through 1.2.37 - June 4, 2009: Glenn
* See also "Contributing Authors", below. * See also "Contributing Authors", below.
* *
* Note about libpng version numbers: * Note about libpng version numbers:
@@ -222,6 +222,13 @@
* 1.2.35rc01-02 13 10235 12.so.0.35[.0] * 1.2.35rc01-02 13 10235 12.so.0.35[.0]
* 1.0.43 10 10043 10.so.0.43[.0] * 1.0.43 10 10043 10.so.0.43[.0]
* 1.2.35 13 10235 12.so.0.35[.0] * 1.2.35 13 10235 12.so.0.35[.0]
* 1.2.36beta01-05 13 10236 12.so.0.36[.0]
* 1.2.36rc01 13 10236 12.so.0.36[.0]
* 1.0.44 10 10044 10.so.0.44[.0]
* 1.2.36 13 10236 12.so.0.36[.0]
* 1.2.37beta01-03 13 10237 12.so.0.37[.0]
* 1.2.37rc01 13 10237 12.so.0.37[.0]
* 1.2.37 13 10237 12.so.0.37[.0]
* *
* Henceforth the source version will match the shared-library major * Henceforth the source version will match the shared-library major
* and minor numbers; the shared-library major version number will be * and minor numbers; the shared-library major version number will be
@@ -251,8 +258,8 @@
* If you modify libpng you may insert additional notices immediately following * If you modify libpng you may insert additional notices immediately following
* this sentence. * this sentence.
* *
* libpng versions 1.2.6, August 15, 2004, through 1.2.35, February 14, 2009, are * libpng versions 1.2.6, August 15, 2004, through 1.2.37, June 4, 2009, are
* Copyright (c) 2004, 2006-2008 Glenn Randers-Pehrson, and are * Copyright (c) 2004, 2006-2009 Glenn Randers-Pehrson, and are
* distributed according to the same disclaimer and license as libpng-1.2.5 * distributed according to the same disclaimer and license as libpng-1.2.5
* with the following individual added to the list of Contributing Authors: * with the following individual added to the list of Contributing Authors:
* *
@@ -363,13 +370,13 @@
* Y2K compliance in libpng: * Y2K compliance in libpng:
* ========================= * =========================
* *
* February 14, 2009 * June 4, 2009
* *
* Since the PNG Development group is an ad-hoc body, we can't make * Since the PNG Development group is an ad-hoc body, we can't make
* an official declaration. * an official declaration.
* *
* This is your unofficial assurance that libpng from version 0.71 and * This is your unofficial assurance that libpng from version 0.71 and
* upward through 1.2.35 are Y2K compliant. It is my belief that earlier * upward through 1.2.37 are Y2K compliant. It is my belief that earlier
* versions were also Y2K compliant. * versions were also Y2K compliant.
* *
* Libpng only has three year fields. One is a 2-byte unsigned integer * Libpng only has three year fields. One is a 2-byte unsigned integer
@@ -425,9 +432,9 @@
*/ */
/* Version information for png.h - this should match the version in png.c */ /* Version information for png.h - this should match the version in png.c */
#define PNG_LIBPNG_VER_STRING "1.2.35" #define PNG_LIBPNG_VER_STRING "1.2.37"
#define PNG_HEADER_VERSION_STRING \ #define PNG_HEADER_VERSION_STRING \
" libpng version 1.2.35 - February 14, 2009\n" " libpng version 1.2.37 - June 4, 2009\n"
#define PNG_LIBPNG_VER_SONUM 0 #define PNG_LIBPNG_VER_SONUM 0
#define PNG_LIBPNG_VER_DLLNUM 13 #define PNG_LIBPNG_VER_DLLNUM 13
@@ -435,7 +442,7 @@
/* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */ /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
#define PNG_LIBPNG_VER_MAJOR 1 #define PNG_LIBPNG_VER_MAJOR 1
#define PNG_LIBPNG_VER_MINOR 2 #define PNG_LIBPNG_VER_MINOR 2
#define PNG_LIBPNG_VER_RELEASE 35 #define PNG_LIBPNG_VER_RELEASE 37
/* This should match the numeric part of the final component of /* This should match the numeric part of the final component of
* PNG_LIBPNG_VER_STRING, omitting any leading zero: */ * PNG_LIBPNG_VER_STRING, omitting any leading zero: */
@@ -463,7 +470,7 @@
* Versions 0.7 through 1.0.0 were in the range 0 to 100 here (only * 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.0 was mis-numbered 100 instead of 10000). From
* version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */ * version 1.0.1 it's xxyyzz, where x=major, y=minor, z=release */
#define PNG_LIBPNG_VER 10235 /* 1.2.35 */ #define PNG_LIBPNG_VER 10237 /* 1.2.37 */
#ifndef PNG_VERSION_INFO_ONLY #ifndef PNG_VERSION_INFO_ONLY
/* include the compression library's header */ /* include the compression library's header */
@@ -1487,7 +1494,7 @@ struct png_struct_def
/* This triggers a compiler error in png.c, if png.c and png.h /* This triggers a compiler error in png.c, if png.c and png.h
* do not agree upon the version number. * do not agree upon the version number.
*/ */
typedef png_structp version_1_2_35; typedef png_structp version_1_2_37;
typedef png_struct FAR * FAR * png_structpp; typedef png_struct FAR * FAR * png_structpp;
@@ -1987,6 +1994,11 @@ extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr));
* If buffered output is not used, then output_flush_fn can be set to NULL. * If buffered output is not used, then output_flush_fn can be set to NULL.
* If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time
* output_flush_fn will be ignored (and thus can be NULL). * output_flush_fn will be ignored (and thus can be NULL).
* It is probably a mistake to use NULL for output_flush_fn if
* write_data_fn is not also NULL unless you have built libpng with
* PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's
* default flush function, which uses the standard *FILE structure, will
* be used.
*/ */
extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr,
png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn));
@@ -2556,64 +2568,72 @@ extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr,
#ifndef PNG_DEBUG_FILE #ifndef PNG_DEBUG_FILE
#define PNG_DEBUG_FILE stderr #define PNG_DEBUG_FILE stderr
#endif /* PNG_DEBUG_FILE */ #endif /* PNG_DEBUG_FILE */
#if (PNG_DEBUG > 1) #if (PNG_DEBUG > 1)
#ifndef png_debug
/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on /* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on
* non-ISO compilers */ * non-ISO compilers */
#ifdef __STDC__ # ifdef __STDC__
#define png_debug(l,m) \ # ifndef png_debug
{ \ # define png_debug(l,m) \
int num_tabs=l; \ { \
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ int num_tabs=l; \
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\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 # endif
#define png_debug1(l,m,p1) \ # ifndef png_debug1
{ \ # define png_debug1(l,m,p1) \
int num_tabs=l; \ { \
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ int num_tabs=l; \
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ 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 # endif
#define png_debug2(l,m,p1,p2) \ # ifndef png_debug2
{ \ # define png_debug2(l,m,p1,p2) \
int num_tabs=l; \ { \
fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ int num_tabs=l; \
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ 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 __ */ # endif
#ifndef png_debug # else /* __STDC __ */
#define png_debug(l,m) \ # ifndef png_debug
int num_tabs=l; \ # define png_debug(l,m) \
char format[256]; \ { \
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ int num_tabs=l; \
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ char format[256]; \
m,PNG_STRING_NEWLINE); \ snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
fprintf(PNG_DEBUG_FILE,format); (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
#endif m,PNG_STRING_NEWLINE); \
#ifndef png_debug1 fprintf(PNG_DEBUG_FILE,format); \
#define png_debug1(l,m,p1) \ }
int num_tabs=l; \ # endif
char format[256]; \ # ifndef png_debug1
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ # define png_debug1(l,m,p1) \
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ { \
m,PNG_STRING_NEWLINE); \ int num_tabs=l; \
fprintf(PNG_DEBUG_FILE,format,p1); char format[256]; \
#endif snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \
#ifndef png_debug2 (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \
#define png_debug2(l,m,p1,p2) \ m,PNG_STRING_NEWLINE); \
int num_tabs=l; \ fprintf(PNG_DEBUG_FILE,format,p1); \
char format[256]; \ }
snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ # endif
(num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ # ifndef png_debug2
m,PNG_STRING_NEWLINE); \ # define png_debug2(l,m,p1,p2) \
fprintf(PNG_DEBUG_FILE,format,p1,p2); { \
#endif int num_tabs=l; \
#endif /* __STDC __ */ 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 /* (PNG_DEBUG > 1) */
#endif /* _MSC_VER */ #endif /* _MSC_VER */
#endif /* (PNG_DEBUG > 0) */ #endif /* (PNG_DEBUG > 0) */
#endif /* PNG_DEBUG */ #endif /* PNG_DEBUG */
@@ -2708,6 +2728,7 @@ extern PNG_EXPORT(void,png_set_mmx_thresholds)
#if !defined(PNG_1_0_X) #if !defined(PNG_1_0_X)
/* png.c, pnggccrd.c, or pngvcrd.c */ /* png.c, pnggccrd.c, or pngvcrd.c */
extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); extern PNG_EXPORT(int,png_mmx_support) PNGARG((void));
#endif /* PNG_1_0_X */
#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ #endif /* PNG_ASSEMBLER_CODE_SUPPORTED */
/* Strip the prepended error numbers ("#nnn ") from error and warning /* Strip the prepended error numbers ("#nnn ") from error and warning
@@ -2717,8 +2738,6 @@ extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp
png_ptr, png_uint_32 strip_mode)); png_ptr, png_uint_32 strip_mode));
#endif #endif
#endif /* PNG_1_0_X */
/* Added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp
headers/libs/png/pngconf.h
+22 -15
View File
@@ -1,7 +1,7 @@
/* pngconf.h - machine configurable file for libpng /* pngconf.h - machine configurable file for libpng
* *
* libpng version 1.2.35 - February 14, 2009 * libpng version 1.2.37 - June 4, 2009
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -314,21 +314,29 @@
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* This is an attempt to force a single setjmp behaviour on Linux. If /* This is an attempt to force a single setjmp behaviour on Linux. If
* the X config stuff didn't define _BSD_SOURCE we wouldn't need this. * the X config stuff didn't define _BSD_SOURCE we wouldn't need this.
*
* You can bypass this test if you know that your application uses exactly
* the same setjmp.h that was included when libpng was built. Only define
* PNG_SKIP_SETJMP_CHECK while building your application, prior to the
* application's '#include "png.h"'. Don't define PNG_SKIP_SETJMP_CHECK
* while building a separate libpng library for general use.
*/ */
# ifdef __linux__ # ifndef PNG_SKIP_SETJMP_CHECK
# ifdef _BSD_SOURCE # ifdef __linux__
# define PNG_SAVE_BSD_SOURCE # ifdef _BSD_SOURCE
# undef _BSD_SOURCE # define PNG_SAVE_BSD_SOURCE
# endif # undef _BSD_SOURCE
# ifdef _SETJMP_H # endif
/* If you encounter a compiler error here, see the explanation # ifdef _SETJMP_H
* near the end of INSTALL. /* If you encounter a compiler error here, see the explanation
*/ * near the end of INSTALL.
__pngconf.h__ already includes setjmp.h; */
__dont__ include it again.; __pngconf.h__ in libpng already includes setjmp.h;
# endif __dont__ include it again.;
# endif /* __linux__ */ # endif
# endif /* __linux__ */
# endif /* PNG_SKIP_SETJMP_CHECK */
/* include setjmp.h for error handling */ /* include setjmp.h for error handling */
# include <setjmp.h> # include <setjmp.h>
@@ -800,7 +808,6 @@
# define PNG_USER_HEIGHT_MAX 1000000L # define PNG_USER_HEIGHT_MAX 1000000L
#endif #endif
/* Added at libpng-1.2.34 and 1.4.0 */ /* Added at libpng-1.2.34 and 1.4.0 */
#ifndef PNG_STRING_NEWLINE #ifndef PNG_STRING_NEWLINE
#define PNG_STRING_NEWLINE "\n" #define PNG_STRING_NEWLINE "\n"
src/libs/png/png.c
+236 -225
View File
@@ -1,9 +1,9 @@
/* png.c - location for general purpose libpng functions /* png.c - location for general purpose libpng functions
* *
* Last changed in libpng 1.2.34 [December 18, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@@ -13,7 +13,7 @@
#include "png.h" #include "png.h"
/* Generate a compiler error if there is an old png.h in the search path. */ /* Generate a compiler error if there is an old png.h in the search path. */
typedef version_1_2_35 Your_png_h_is_not_version_1_2_35; typedef version_1_2_37 Your_png_h_is_not_version_1_2_37;
/* Version information for C files. This had better match the version /* Version information for C files. This had better match the version
* string defined in png.h. */ * string defined in png.h. */
@@ -53,18 +53,18 @@ PNG_tRNS;
PNG_zTXt; PNG_zTXt;
#ifdef PNG_READ_SUPPORTED #ifdef PNG_READ_SUPPORTED
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
/* offset to next interlace block in the y direction */ /* Offset to next interlace block in the y direction */
PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
/* Height of interlace block. This is not currently used - if you need /* Height of interlace block. This is not currently used - if you need
@@ -92,7 +92,8 @@ PNG_CONST int FARDATA png_pass_dsp_mask[]
void PNGAPI void PNGAPI
png_set_sig_bytes(png_structp png_ptr, int num_bytes) png_set_sig_bytes(png_structp png_ptr, int num_bytes)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_debug(1, "in png_set_sig_bytes"); png_debug(1, "in png_set_sig_bytes");
if (num_bytes > 8) if (num_bytes > 8)
png_error(png_ptr, "Too many bytes for PNG signature."); png_error(png_ptr, "Too many bytes for PNG signature.");
@@ -153,7 +154,8 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
png_uint_32 save_flags=p->flags; png_uint_32 save_flags=p->flags;
png_uint_32 num_bytes; png_uint_32 num_bytes;
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
if (items > PNG_UINT_32_MAX/size) if (items > PNG_UINT_32_MAX/size)
{ {
png_warning (p, "Potential overflow in png_zalloc()"); png_warning (p, "Potential overflow in png_zalloc()");
@@ -183,7 +185,7 @@ png_zalloc(voidpf png_ptr, uInt items, uInt size)
return ((voidpf)ptr); return ((voidpf)ptr);
} }
/* function to free memory for zlib */ /* Function to free memory for zlib */
#ifdef PNG_1_0_X #ifdef PNG_1_0_X
void PNGAPI void PNGAPI
#else #else
@@ -241,7 +243,8 @@ png_create_info_struct(png_structp png_ptr)
png_infop info_ptr; png_infop info_ptr;
png_debug(1, "in png_create_info_struct"); png_debug(1, "in png_create_info_struct");
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO, info_ptr = (png_infop)png_create_struct_2(PNG_STRUCT_INFO,
png_ptr->malloc_fn, png_ptr->mem_ptr); png_ptr->malloc_fn, png_ptr->mem_ptr);
@@ -263,7 +266,8 @@ void PNGAPI
png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr) png_destroy_info_struct(png_structp png_ptr, png_infopp info_ptr_ptr)
{ {
png_infop info_ptr = NULL; png_infop info_ptr = NULL;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_debug(1, "in png_destroy_info_struct"); png_debug(1, "in png_destroy_info_struct");
if (info_ptr_ptr != NULL) if (info_ptr_ptr != NULL)
@@ -302,18 +306,19 @@ png_info_init_3(png_infopp ptr_ptr, png_size_t png_info_struct_size)
{ {
png_infop info_ptr = *ptr_ptr; png_infop info_ptr = *ptr_ptr;
if (info_ptr == NULL) return; if (info_ptr == NULL)
return;
png_debug(1, "in png_info_init_3"); png_debug(1, "in png_info_init_3");
if (png_sizeof(png_info) > png_info_struct_size) if (png_sizeof(png_info) > png_info_struct_size)
{ {
png_destroy_struct(info_ptr); png_destroy_struct(info_ptr);
info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO); info_ptr = (png_infop)png_create_struct(PNG_STRUCT_INFO);
*ptr_ptr = info_ptr; *ptr_ptr = info_ptr;
} }
/* set everything to 0 */ /* Set everything to 0 */
png_memset(info_ptr, 0, png_sizeof(png_info)); png_memset(info_ptr, 0, png_sizeof(png_info));
} }
@@ -344,245 +349,245 @@ png_free_data(png_structp png_ptr, png_infop info_ptr, png_uint_32 mask,
return; return;
#if defined(PNG_TEXT_SUPPORTED) #if defined(PNG_TEXT_SUPPORTED)
/* free text item num or (if num == -1) all text items */ /* Free text item num or (if num == -1) all text items */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_TEXT) & info_ptr->free_me) if ((mask & PNG_FREE_TEXT) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_TEXT) if (mask & PNG_FREE_TEXT)
#endif #endif
{
if (num != -1)
{ {
if (info_ptr->text && info_ptr->text[num].key) if (num != -1)
{ {
png_free(png_ptr, info_ptr->text[num].key); if (info_ptr->text && info_ptr->text[num].key)
info_ptr->text[num].key = NULL; {
} png_free(png_ptr, info_ptr->text[num].key);
info_ptr->text[num].key = NULL;
}
}
else
{
int i;
for (i = 0; i < info_ptr->num_text; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
png_free(png_ptr, info_ptr->text);
info_ptr->text = NULL;
info_ptr->num_text=0;
}
} }
else
{
int i;
for (i = 0; i < info_ptr->num_text; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_TEXT, i);
png_free(png_ptr, info_ptr->text);
info_ptr->text = NULL;
info_ptr->num_text=0;
}
}
#endif #endif
#if defined(PNG_tRNS_SUPPORTED) #if defined(PNG_tRNS_SUPPORTED)
/* free any tRNS entry */ /* Free any tRNS entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_TRNS) & info_ptr->free_me) if ((mask & PNG_FREE_TRNS) & info_ptr->free_me)
#else #else
if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS)) if ((mask & PNG_FREE_TRNS) && (png_ptr->flags & PNG_FLAG_FREE_TRNS))
#endif #endif
{ {
png_free(png_ptr, info_ptr->trans); png_free(png_ptr, info_ptr->trans);
info_ptr->trans = NULL; info_ptr->trans = NULL;
info_ptr->valid &= ~PNG_INFO_tRNS; info_ptr->valid &= ~PNG_INFO_tRNS;
#ifndef PNG_FREE_ME_SUPPORTED #ifndef PNG_FREE_ME_SUPPORTED
png_ptr->flags &= ~PNG_FLAG_FREE_TRNS; png_ptr->flags &= ~PNG_FLAG_FREE_TRNS;
#endif #endif
} }
#endif #endif
#if defined(PNG_sCAL_SUPPORTED) #if defined(PNG_sCAL_SUPPORTED)
/* free any sCAL entry */ /* Free any sCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SCAL) & info_ptr->free_me) if ((mask & PNG_FREE_SCAL) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_SCAL) if (mask & PNG_FREE_SCAL)
#endif #endif
{ {
#if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED) #if defined(PNG_FIXED_POINT_SUPPORTED) && !defined(PNG_FLOATING_POINT_SUPPORTED)
png_free(png_ptr, info_ptr->scal_s_width); png_free(png_ptr, info_ptr->scal_s_width);
png_free(png_ptr, info_ptr->scal_s_height); png_free(png_ptr, info_ptr->scal_s_height);
info_ptr->scal_s_width = NULL; info_ptr->scal_s_width = NULL;
info_ptr->scal_s_height = NULL; info_ptr->scal_s_height = NULL;
#endif #endif
info_ptr->valid &= ~PNG_INFO_sCAL; info_ptr->valid &= ~PNG_INFO_sCAL;
} }
#endif #endif
#if defined(PNG_pCAL_SUPPORTED) #if defined(PNG_pCAL_SUPPORTED)
/* free any pCAL entry */ /* Free any pCAL entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_PCAL) & info_ptr->free_me) if ((mask & PNG_FREE_PCAL) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_PCAL) if (mask & PNG_FREE_PCAL)
#endif #endif
{ {
png_free(png_ptr, info_ptr->pcal_purpose); png_free(png_ptr, info_ptr->pcal_purpose);
png_free(png_ptr, info_ptr->pcal_units); png_free(png_ptr, info_ptr->pcal_units);
info_ptr->pcal_purpose = NULL; info_ptr->pcal_purpose = NULL;
info_ptr->pcal_units = NULL; info_ptr->pcal_units = NULL;
if (info_ptr->pcal_params != NULL) if (info_ptr->pcal_params != NULL)
{ {
int i; int i;
for (i = 0; i < (int)info_ptr->pcal_nparams; i++) for (i = 0; i < (int)info_ptr->pcal_nparams; i++)
{ {
png_free(png_ptr, info_ptr->pcal_params[i]); png_free(png_ptr, info_ptr->pcal_params[i]);
info_ptr->pcal_params[i]=NULL; info_ptr->pcal_params[i]=NULL;
} }
png_free(png_ptr, info_ptr->pcal_params); png_free(png_ptr, info_ptr->pcal_params);
info_ptr->pcal_params = NULL; info_ptr->pcal_params = NULL;
} }
info_ptr->valid &= ~PNG_INFO_pCAL; info_ptr->valid &= ~PNG_INFO_pCAL;
} }
#endif #endif
#if defined(PNG_iCCP_SUPPORTED) #if defined(PNG_iCCP_SUPPORTED)
/* free any iCCP entry */ /* Free any iCCP entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_ICCP) & info_ptr->free_me) if ((mask & PNG_FREE_ICCP) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_ICCP) if (mask & PNG_FREE_ICCP)
#endif #endif
{ {
png_free(png_ptr, info_ptr->iccp_name); png_free(png_ptr, info_ptr->iccp_name);
png_free(png_ptr, info_ptr->iccp_profile); png_free(png_ptr, info_ptr->iccp_profile);
info_ptr->iccp_name = NULL; info_ptr->iccp_name = NULL;
info_ptr->iccp_profile = NULL; info_ptr->iccp_profile = NULL;
info_ptr->valid &= ~PNG_INFO_iCCP; info_ptr->valid &= ~PNG_INFO_iCCP;
} }
#endif #endif
#if defined(PNG_sPLT_SUPPORTED) #if defined(PNG_sPLT_SUPPORTED)
/* free a given sPLT entry, or (if num == -1) all sPLT entries */ /* Free a given sPLT entry, or (if num == -1) all sPLT entries */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_SPLT) & info_ptr->free_me) if ((mask & PNG_FREE_SPLT) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_SPLT) if (mask & PNG_FREE_SPLT)
#endif #endif
{
if (num != -1)
{ {
if (info_ptr->splt_palettes) if (num != -1)
{ {
png_free(png_ptr, info_ptr->splt_palettes[num].name); if (info_ptr->splt_palettes)
png_free(png_ptr, info_ptr->splt_palettes[num].entries); {
info_ptr->splt_palettes[num].name = NULL; png_free(png_ptr, info_ptr->splt_palettes[num].name);
info_ptr->splt_palettes[num].entries = NULL; png_free(png_ptr, info_ptr->splt_palettes[num].entries);
info_ptr->splt_palettes[num].name = NULL;
info_ptr->splt_palettes[num].entries = NULL;
}
}
else
{
if (info_ptr->splt_palettes_num)
{
int i;
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
png_free(png_ptr, info_ptr->splt_palettes);
info_ptr->splt_palettes = NULL;
info_ptr->splt_palettes_num = 0;
}
info_ptr->valid &= ~PNG_INFO_sPLT;
} }
} }
else
{
if (info_ptr->splt_palettes_num)
{
int i;
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_SPLT, i);
png_free(png_ptr, info_ptr->splt_palettes);
info_ptr->splt_palettes = NULL;
info_ptr->splt_palettes_num = 0;
}
info_ptr->valid &= ~PNG_INFO_sPLT;
}
}
#endif #endif
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
if (png_ptr->unknown_chunk.data) if (png_ptr->unknown_chunk.data)
{ {
png_free(png_ptr, png_ptr->unknown_chunk.data); png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr->unknown_chunk.data = NULL; png_ptr->unknown_chunk.data = NULL;
} }
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_UNKN) & info_ptr->free_me) if ((mask & PNG_FREE_UNKN) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_UNKN) if (mask & PNG_FREE_UNKN)
#endif #endif
{
if (num != -1)
{ {
if (info_ptr->unknown_chunks) if (num != -1)
{ {
png_free(png_ptr, info_ptr->unknown_chunks[num].data); if (info_ptr->unknown_chunks)
info_ptr->unknown_chunks[num].data = NULL; {
} png_free(png_ptr, info_ptr->unknown_chunks[num].data);
} info_ptr->unknown_chunks[num].data = NULL;
else }
{ }
int i; else
{
int i;
if (info_ptr->unknown_chunks_num) if (info_ptr->unknown_chunks_num)
{ {
for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++) for (i = 0; i < (int)info_ptr->unknown_chunks_num; i++)
png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i); png_free_data(png_ptr, info_ptr, PNG_FREE_UNKN, i);
png_free(png_ptr, info_ptr->unknown_chunks); png_free(png_ptr, info_ptr->unknown_chunks);
info_ptr->unknown_chunks = NULL; info_ptr->unknown_chunks = NULL;
info_ptr->unknown_chunks_num = 0; info_ptr->unknown_chunks_num = 0;
} }
}
} }
}
#endif #endif
#if defined(PNG_hIST_SUPPORTED) #if defined(PNG_hIST_SUPPORTED)
/* free any hIST entry */ /* Free any hIST entry */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_HIST) & info_ptr->free_me) if ((mask & PNG_FREE_HIST) & info_ptr->free_me)
#else #else
if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST)) if ((mask & PNG_FREE_HIST) && (png_ptr->flags & PNG_FLAG_FREE_HIST))
#endif #endif
{ {
png_free(png_ptr, info_ptr->hist); png_free(png_ptr, info_ptr->hist);
info_ptr->hist = NULL; info_ptr->hist = NULL;
info_ptr->valid &= ~PNG_INFO_hIST; info_ptr->valid &= ~PNG_INFO_hIST;
#ifndef PNG_FREE_ME_SUPPORTED #ifndef PNG_FREE_ME_SUPPORTED
png_ptr->flags &= ~PNG_FLAG_FREE_HIST; png_ptr->flags &= ~PNG_FLAG_FREE_HIST;
#endif #endif
} }
#endif #endif
/* free any PLTE entry that was internally allocated */ /* Free any PLTE entry that was internally allocated */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_PLTE) & info_ptr->free_me) if ((mask & PNG_FREE_PLTE) & info_ptr->free_me)
#else #else
if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE)) if ((mask & PNG_FREE_PLTE) && (png_ptr->flags & PNG_FLAG_FREE_PLTE))
#endif #endif
{ {
png_zfree(png_ptr, info_ptr->palette); png_zfree(png_ptr, info_ptr->palette);
info_ptr->palette = NULL; info_ptr->palette = NULL;
info_ptr->valid &= ~PNG_INFO_PLTE; info_ptr->valid &= ~PNG_INFO_PLTE;
#ifndef PNG_FREE_ME_SUPPORTED #ifndef PNG_FREE_ME_SUPPORTED
png_ptr->flags &= ~PNG_FLAG_FREE_PLTE; png_ptr->flags &= ~PNG_FLAG_FREE_PLTE;
#endif #endif
info_ptr->num_palette = 0; info_ptr->num_palette = 0;
} }
#if defined(PNG_INFO_IMAGE_SUPPORTED) #if defined(PNG_INFO_IMAGE_SUPPORTED)
/* free any image bits attached to the info structure */ /* Free any image bits attached to the info structure */
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if ((mask & PNG_FREE_ROWS) & info_ptr->free_me) if ((mask & PNG_FREE_ROWS) & info_ptr->free_me)
#else #else
if (mask & PNG_FREE_ROWS) if (mask & PNG_FREE_ROWS)
#endif #endif
{ {
if (info_ptr->row_pointers) if (info_ptr->row_pointers)
{ {
int row; int row;
for (row = 0; row < (int)info_ptr->height; row++) for (row = 0; row < (int)info_ptr->height; row++)
{ {
png_free(png_ptr, info_ptr->row_pointers[row]); png_free(png_ptr, info_ptr->row_pointers[row]);
info_ptr->row_pointers[row]=NULL; info_ptr->row_pointers[row]=NULL;
} }
png_free(png_ptr, info_ptr->row_pointers); png_free(png_ptr, info_ptr->row_pointers);
info_ptr->row_pointers=NULL; info_ptr->row_pointers=NULL;
} }
info_ptr->valid &= ~PNG_INFO_IDAT; info_ptr->valid &= ~PNG_INFO_IDAT;
} }
#endif #endif
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
if (num == -1) if (num == -1)
info_ptr->free_me &= ~mask; info_ptr->free_me &= ~mask;
else else
info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL); info_ptr->free_me &= ~(mask & ~PNG_FREE_MUL);
#endif #endif
} }
@@ -600,9 +605,9 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
if (png_ptr->num_chunk_list) if (png_ptr->num_chunk_list)
{ {
png_free(png_ptr, png_ptr->chunk_list); png_free(png_ptr, png_ptr->chunk_list);
png_ptr->chunk_list=NULL; png_ptr->chunk_list=NULL;
png_ptr->num_chunk_list = 0; png_ptr->num_chunk_list = 0;
} }
#endif #endif
@@ -617,7 +622,8 @@ png_info_destroy(png_structp png_ptr, png_infop info_ptr)
png_voidp PNGAPI png_voidp PNGAPI
png_get_io_ptr(png_structp png_ptr) png_get_io_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
return (png_ptr->io_ptr); return (png_ptr->io_ptr);
} }
@@ -633,7 +639,8 @@ void PNGAPI
png_init_io(png_structp png_ptr, png_FILE_p fp) png_init_io(png_structp png_ptr, png_FILE_p fp)
{ {
png_debug(1, "in png_init_io"); png_debug(1, "in png_init_io");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->io_ptr = (png_voidp)fp; png_ptr->io_ptr = (png_voidp)fp;
} }
#endif #endif
@@ -649,7 +656,8 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
{"Jan", "Feb", "Mar", "Apr", "May", "Jun", {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
if (png_ptr->time_buffer == NULL) if (png_ptr->time_buffer == NULL)
{ {
png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29* png_ptr->time_buffer = (png_charp)png_malloc(png_ptr, (png_uint_32)(29*
@@ -693,9 +701,9 @@ png_convert_to_rfc1123(png_structp png_ptr, png_timep ptime)
png_charp PNGAPI png_charp PNGAPI
png_get_copyright(png_structp png_ptr) png_get_copyright(png_structp png_ptr)
{ {
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) "\n libpng version 1.2.35 - February 14, 2009\n\ return ((png_charp) "\n libpng version 1.2.37 - June 4, 2009\n\
Copyright (c) 1998-2008 Glenn Randers-Pehrson\n\ Copyright (c) 1998-2009 Glenn Randers-Pehrson\n\
Copyright (c) 1996-1997 Andreas Dilger\n\ Copyright (c) 1996-1997 Andreas Dilger\n\
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n"); Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n");
} }
@@ -712,7 +720,7 @@ png_charp PNGAPI
png_get_libpng_ver(png_structp png_ptr) png_get_libpng_ver(png_structp png_ptr)
{ {
/* Version of *.c files used when building libpng */ /* Version of *.c files used when building libpng */
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) PNG_LIBPNG_VER_STRING); return ((png_charp) PNG_LIBPNG_VER_STRING);
} }
@@ -720,7 +728,7 @@ png_charp PNGAPI
png_get_header_ver(png_structp png_ptr) png_get_header_ver(png_structp png_ptr)
{ {
/* Version of *.h files used when building libpng */ /* Version of *.h files used when building libpng */
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) PNG_LIBPNG_VER_STRING); return ((png_charp) PNG_LIBPNG_VER_STRING);
} }
@@ -728,7 +736,7 @@ png_charp PNGAPI
png_get_header_version(png_structp png_ptr) png_get_header_version(png_structp png_ptr)
{ {
/* Returns longer string containing both version and date */ /* Returns longer string containing both version and date */
png_ptr = png_ptr; /* silence compiler warning about unused png_ptr */ png_ptr = png_ptr; /* Silence compiler warning about unused png_ptr */
return ((png_charp) PNG_HEADER_VERSION_STRING return ((png_charp) PNG_HEADER_VERSION_STRING
#ifndef PNG_READ_SUPPORTED #ifndef PNG_READ_SUPPORTED
" (NO READ SUPPORT)" " (NO READ SUPPORT)"
@@ -741,7 +749,7 @@ png_get_header_version(png_structp png_ptr)
int PNGAPI int PNGAPI
png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name) png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
{ {
/* check chunk_name and return "keep" value if it's on the list, else 0 */ /* Check chunk_name and return "keep" value if it's on the list, else 0 */
int i; int i;
png_bytep p; png_bytep p;
if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0) if (png_ptr == NULL || chunk_name == NULL || png_ptr->num_chunk_list<=0)
@@ -758,7 +766,8 @@ png_handle_as_unknown(png_structp png_ptr, png_bytep chunk_name)
int PNGAPI int PNGAPI
png_reset_zstream(png_structp png_ptr) png_reset_zstream(png_structp png_ptr)
{ {
if (png_ptr == NULL) return Z_STREAM_ERROR; if (png_ptr == NULL)
return Z_STREAM_ERROR;
return (inflateReset(&png_ptr->zstream)); return (inflateReset(&png_ptr->zstream));
} }
#endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */ #endif /* defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) */
@@ -774,11 +783,11 @@ png_access_version_number(void)
#if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED) #if defined(PNG_READ_SUPPORTED) && defined(PNG_ASSEMBLER_CODE_SUPPORTED)
#if !defined(PNG_1_0_X) #if !defined(PNG_1_0_X)
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
int PNGAPI int PNGAPI
png_mmx_support(void) png_mmx_support(void)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return -1; return -1;
} }
#endif /* PNG_1_0_X */ #endif /* PNG_1_0_X */
@@ -791,53 +800,55 @@ png_mmx_support(void)
png_size_t PNGAPI png_size_t PNGAPI
png_convert_size(size_t size) png_convert_size(size_t size)
{ {
if (size > (png_size_t)-1) if (size > (png_size_t)-1)
PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */ PNG_ABORT(); /* We haven't got access to png_ptr, so no png_error() */
return ((png_size_t)size); return ((png_size_t)size);
} }
#endif /* PNG_SIZE_T */ #endif /* PNG_SIZE_T */
/* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */ /* Added at libpng version 1.2.34 and 1.4.0 (moved from pngset.c) */
#if defined(PNG_cHRM_SUPPORTED) #if defined(PNG_cHRM_SUPPORTED)
#if !defined(PNG_NO_CHECK_cHRM) #if !defined(PNG_NO_CHECK_cHRM)
/* /*
Multiply two 32-bit numbers, V1 and V2, using 32-bit * Multiply two 32-bit numbers, V1 and V2, using 32-bit
arithmetic, to produce a 64 bit result in the HI/LO words. * arithmetic, to produce a 64 bit result in the HI/LO words.
*
A B * A B
x C D * x C D
------ * ------
AD || BD * AD || BD
AC || CB || 0 * AC || CB || 0
*
where A and B are the high and low 16-bit words of V1, * 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 * 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. * A and D, and X || Y is (X << 16) + Y.
*/ */
void png_64bit_product (long v1, long v2, unsigned long *hi_product, void png_64bit_product (long v1, long v2, unsigned long *hi_product,
unsigned long *lo_product) unsigned long *lo_product)
{ {
int a, b, c, d; int a, b, c, d;
long lo, hi, x, y; long lo, hi, x, y;
a = (v1 >> 16) & 0xffff; a = (v1 >> 16) & 0xffff;
b = v1 & 0xffff; b = v1 & 0xffff;
c = (v2 >> 16) & 0xffff; c = (v2 >> 16) & 0xffff;
d = v2 & 0xffff; d = v2 & 0xffff;
lo = b * d; /* BD */ lo = b * d; /* BD */
x = a * d + c * b; /* AD + CB */ x = a * d + c * b; /* AD + CB */
y = ((lo >> 16) & 0xffff) + x; y = ((lo >> 16) & 0xffff) + x;
lo = (lo & 0xffff) | ((y & 0xffff) << 16); lo = (lo & 0xffff) | ((y & 0xffff) << 16);
hi = (y >> 16) & 0xffff; hi = (y >> 16) & 0xffff;
hi += a * c; /* AC */ hi += a * c; /* AC */
*hi_product = (unsigned long)hi; *hi_product = (unsigned long)hi;
*lo_product = (unsigned long)lo; *lo_product = (unsigned long)lo;
} }
int /* private */ int /* private */
png_check_cHRM_fixed(png_structp png_ptr, 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 white_x, png_fixed_point white_y, png_fixed_point red_x,
src/libs/png/pngerror.c
+31 -15
View File
@@ -1,9 +1,9 @@
/* pngerror.c - stub functions for i/o and memory allocation /* pngerror.c - stub functions for i/o and memory allocation
* *
* Last changed in libpng 1.2.34 [December 18, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
@@ -44,7 +44,7 @@ png_error(png_structp png_ptr, png_const_charp error_message)
{ {
if (*error_message == '#') if (*error_message == '#')
{ {
/* Strip "#nnnn " from beginning of error message. */ /* Strip "#nnnn " from beginning of error message. */
int offset; int offset;
for (offset = 1; offset<15; offset++) for (offset = 1; offset<15; offset++)
if (error_message[offset] == ' ') if (error_message[offset] == ' ')
@@ -217,7 +217,7 @@ png_default_error(png_structp png_ptr, png_const_charp error_message)
#ifdef PNG_ERROR_NUMBERS_SUPPORTED #ifdef PNG_ERROR_NUMBERS_SUPPORTED
if (*error_message == '#') if (*error_message == '#')
{ {
/* Strip "#nnnn " from beginning of warning message. */ /* Strip "#nnnn " from beginning of error message. */
int offset; int offset;
char error_number[16]; char error_number[16];
for (offset = 0; offset<15; offset++) for (offset = 0; offset<15; offset++)
@@ -229,15 +229,23 @@ png_default_error(png_structp png_ptr, png_const_charp error_message)
if ((offset > 1) && (offset < 15)) if ((offset > 1) && (offset < 15))
{ {
error_number[offset - 1] = '\0'; error_number[offset - 1] = '\0';
fprintf(stderr, "libpng error no. %s: %s\n", error_number, fprintf(stderr, "libpng error no. %s: %s",
error_message + offset + 1); error_number, error_message + offset + 1);
fprintf(stderr, PNG_STRING_NEWLINE);
} }
else else
fprintf(stderr, "libpng error: %s, offset=%d\n", error_message, offset); {
fprintf(stderr, "libpng error: %s, offset=%d",
error_message, offset);
fprintf(stderr, PNG_STRING_NEWLINE);
}
} }
else else
#endif #endif
fprintf(stderr, "libpng error: %s\n", error_message); {
fprintf(stderr, "libpng error: %s", error_message);
fprintf(stderr, PNG_STRING_NEWLINE);
}
#endif #endif
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
@@ -257,7 +265,7 @@ png_default_error(png_structp png_ptr, png_const_charp error_message)
PNG_ABORT(); PNG_ABORT();
#endif #endif
#ifdef PNG_NO_CONSOLE_IO #ifdef PNG_NO_CONSOLE_IO
error_message = error_message; /* make compiler happy */ error_message = error_message; /* Make compiler happy */
#endif #endif
} }
@@ -285,19 +293,27 @@ png_default_warning(png_structp png_ptr, png_const_charp warning_message)
if ((offset > 1) && (offset < 15)) if ((offset > 1) && (offset < 15))
{ {
warning_number[offset + 1] = '\0'; warning_number[offset + 1] = '\0';
fprintf(stderr, "libpng warning no. %s: %s\n", warning_number, fprintf(stderr, "libpng warning no. %s: %s",
warning_message + offset); warning_number, warning_message + offset);
fprintf(stderr, PNG_STRING_NEWLINE);
} }
else else
fprintf(stderr, "libpng warning: %s\n", warning_message); {
fprintf(stderr, "libpng warning: %s",
warning_message);
fprintf(stderr, PNG_STRING_NEWLINE);
}
} }
else else
# endif # endif
fprintf(stderr, "libpng warning: %s\n", warning_message); {
fprintf(stderr, "libpng warning: %s", warning_message);
fprintf(stderr, PNG_STRING_NEWLINE);
}
#else #else
warning_message = warning_message; /* make compiler happy */ warning_message = warning_message; /* Make compiler happy */
#endif #endif
png_ptr = png_ptr; /* make compiler happy */ png_ptr = png_ptr; /* Make compiler happy */
} }
#endif /* PNG_NO_WARNINGS */ #endif /* PNG_NO_WARNINGS */
src/libs/png/pngget.c
+84 -45
View File
@@ -1,9 +1,9 @@
/* pngget.c - retrieval of values from info struct /* pngget.c - retrieval of values from info struct
* *
* Last changed in libpng 1.2.30 [August 15, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@@ -17,6 +17,7 @@ png_get_valid(png_structp png_ptr, png_infop info_ptr, png_uint_32 flag)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->valid & flag); return(info_ptr->valid & flag);
else else
return(0); return(0);
} }
@@ -26,6 +27,7 @@ png_get_rowbytes(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->rowbytes); return(info_ptr->rowbytes);
else else
return(0); return(0);
} }
@@ -36,20 +38,20 @@ png_get_rows(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
return(info_ptr->row_pointers); return(info_ptr->row_pointers);
else else
return(0); return(0);
} }
#endif #endif
#ifdef PNG_EASY_ACCESS_SUPPORTED #ifdef PNG_EASY_ACCESS_SUPPORTED
/* easy access to info, added in libpng-0.99 */ /* Easy access to info, added in libpng-0.99 */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_image_width(png_structp png_ptr, png_infop info_ptr) png_get_image_width(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->width; return info_ptr->width;
}
return (0); return (0);
} }
@@ -57,9 +59,8 @@ png_uint_32 PNGAPI
png_get_image_height(png_structp png_ptr, png_infop info_ptr) png_get_image_height(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->height; return info_ptr->height;
}
return (0); return (0);
} }
@@ -67,9 +68,8 @@ png_byte PNGAPI
png_get_bit_depth(png_structp png_ptr, png_infop info_ptr) png_get_bit_depth(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->bit_depth; return info_ptr->bit_depth;
}
return (0); return (0);
} }
@@ -77,9 +77,8 @@ png_byte PNGAPI
png_get_color_type(png_structp png_ptr, png_infop info_ptr) png_get_color_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->color_type; return info_ptr->color_type;
}
return (0); return (0);
} }
@@ -87,9 +86,8 @@ png_byte PNGAPI
png_get_filter_type(png_structp png_ptr, png_infop info_ptr) png_get_filter_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->filter_type; return info_ptr->filter_type;
}
return (0); return (0);
} }
@@ -97,9 +95,8 @@ png_byte PNGAPI
png_get_interlace_type(png_structp png_ptr, png_infop info_ptr) png_get_interlace_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->interlace_type; return info_ptr->interlace_type;
}
return (0); return (0);
} }
@@ -107,9 +104,8 @@ png_byte PNGAPI
png_get_compression_type(png_structp png_ptr, png_infop info_ptr) png_get_compression_type(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
{
return info_ptr->compression_type; return info_ptr->compression_type;
}
return (0); return (0);
} }
@@ -121,9 +117,12 @@ png_get_x_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "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) if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0); return (0);
else return (info_ptr->x_pixels_per_unit);
else
return (info_ptr->x_pixels_per_unit);
} }
#else #else
return (0); return (0);
@@ -139,9 +138,12 @@ png_get_y_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "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) if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER)
return (0); return (0);
else return (info_ptr->y_pixels_per_unit);
else
return (info_ptr->y_pixels_per_unit);
} }
#else #else
return (0); return (0);
@@ -157,10 +159,13 @@ png_get_pixels_per_meter(png_structp png_ptr, png_infop info_ptr)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "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 || if (info_ptr->phys_unit_type != PNG_RESOLUTION_METER ||
info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit) info_ptr->x_pixels_per_unit != info_ptr->y_pixels_per_unit)
return (0); return (0);
else return (info_ptr->x_pixels_per_unit);
else
return (info_ptr->x_pixels_per_unit);
} }
#else #else
return (0); return (0);
@@ -174,6 +179,7 @@ png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_pHYs_SUPPORTED) #if defined(PNG_pHYs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
{ {
png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio"); png_debug1(1, "in %s retrieval function", "png_get_aspect_ratio");
@@ -184,7 +190,7 @@ png_get_pixel_aspect_ratio(png_structp png_ptr, png_infop info_ptr)
/(float)info_ptr->x_pixels_per_unit)); /(float)info_ptr->x_pixels_per_unit));
} }
#else #else
return (0.0); return (0.0);
#endif #endif
return ((float)0.0); return ((float)0.0);
} }
@@ -195,15 +201,19 @@ png_get_x_offset_microns(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "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) if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0); return (0);
else return (info_ptr->x_offset);
else
return (info_ptr->x_offset);
} }
#else #else
return (0); return (0);
#endif #endif
return (0); return (0);
} }
@@ -212,13 +222,17 @@ png_int_32 PNGAPI
png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr) png_get_y_offset_microns(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "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) if (info_ptr->offset_unit_type != PNG_OFFSET_MICROMETER)
return (0); return (0);
else return (info_ptr->y_offset);
else
return (info_ptr->y_offset);
} }
#else #else
return (0); return (0);
@@ -230,13 +244,17 @@ png_int_32 PNGAPI
png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr) png_get_x_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "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) if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0); return (0);
else return (info_ptr->x_offset);
else
return (info_ptr->x_offset);
} }
#else #else
return (0); return (0);
@@ -248,13 +266,17 @@ png_int_32 PNGAPI
png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr) png_get_y_offset_pixels(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr != NULL && info_ptr != NULL) if (png_ptr != NULL && info_ptr != NULL)
#if defined(PNG_oFFs_SUPPORTED) #if defined(PNG_oFFs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_oFFs) if (info_ptr->valid & PNG_INFO_oFFs)
{ {
png_debug1(1, "in %s retrieval function", "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) if (info_ptr->offset_unit_type != PNG_OFFSET_PIXEL)
return (0); return (0);
else return (info_ptr->y_offset);
else
return (info_ptr->y_offset);
} }
#else #else
return (0); return (0);
@@ -495,8 +517,9 @@ png_get_iCCP(png_structp png_ptr, png_infop info_ptr,
png_debug1(1, "in %s retrieval function", "iCCP"); png_debug1(1, "in %s retrieval function", "iCCP");
*name = info_ptr->iccp_name; *name = info_ptr->iccp_name;
*profile = info_ptr->iccp_profile; *profile = info_ptr->iccp_profile;
/* compression_type is a dummy so the API won't have to change /* Compression_type is a dummy so the API won't have to change
if we introduce multiple compression types later. */ * if we introduce multiple compression types later.
*/
*proflen = (int)info_ptr->iccp_proflen; *proflen = (int)info_ptr->iccp_proflen;
*compression_type = (int)info_ptr->iccp_compression; *compression_type = (int)info_ptr->iccp_compression;
return (PNG_INFO_iCCP); return (PNG_INFO_iCCP);
@@ -549,22 +572,29 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
*height = info_ptr->height; *height = info_ptr->height;
*bit_depth = info_ptr->bit_depth; *bit_depth = info_ptr->bit_depth;
if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16) if (info_ptr->bit_depth < 1 || info_ptr->bit_depth > 16)
png_error(png_ptr, "Invalid bit depth"); png_error(png_ptr, "Invalid bit depth");
*color_type = info_ptr->color_type; *color_type = info_ptr->color_type;
if (info_ptr->color_type > 6) if (info_ptr->color_type > 6)
png_error(png_ptr, "Invalid color type"); png_error(png_ptr, "Invalid color type");
if (compression_type != NULL) if (compression_type != NULL)
*compression_type = info_ptr->compression_type; *compression_type = info_ptr->compression_type;
if (filter_type != NULL) if (filter_type != NULL)
*filter_type = info_ptr->filter_type; *filter_type = info_ptr->filter_type;
if (interlace_type != NULL) if (interlace_type != NULL)
*interlace_type = info_ptr->interlace_type; *interlace_type = info_ptr->interlace_type;
/* check for potential overflow of rowbytes */ /* Check for potential overflow of rowbytes */
if (*width == 0 || *width > PNG_UINT_31_MAX) if (*width == 0 || *width > PNG_UINT_31_MAX)
png_error(png_ptr, "Invalid image width"); png_error(png_ptr, "Invalid image width");
if (*height == 0 || *height > PNG_UINT_31_MAX) if (*height == 0 || *height > PNG_UINT_31_MAX)
png_error(png_ptr, "Invalid image height"); png_error(png_ptr, "Invalid image height");
if (info_ptr->width > (PNG_UINT_32_MAX if (info_ptr->width > (PNG_UINT_32_MAX
>> 3) /* 8-byte RGBA pixels */ >> 3) /* 8-byte RGBA pixels */
- 64 /* bigrowbuf hack */ - 64 /* bigrowbuf hack */
@@ -575,6 +605,7 @@ png_get_IHDR(png_structp png_ptr, png_infop info_ptr,
png_warning(png_ptr, png_warning(png_ptr,
"Width too large for libpng to process image data."); "Width too large for libpng to process image data.");
} }
return (1); return (1);
} }
return (0); return (0);
@@ -605,8 +636,8 @@ png_get_pCAL(png_structp png_ptr, png_infop info_ptr,
png_charp *units, png_charpp *params) png_charp *units, png_charpp *params)
{ {
if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL) if (png_ptr != NULL && info_ptr != NULL && (info_ptr->valid & PNG_INFO_pCAL)
&& purpose != NULL && X0 != NULL && X1 != NULL && type != NULL && && purpose != NULL && X0 != NULL && X1 != NULL && type != NULL &&
nparams != NULL && units != NULL && params != NULL) nparams != NULL && units != NULL && params != NULL)
{ {
png_debug1(1, "in %s retrieval function", "pCAL"); png_debug1(1, "in %s retrieval function", "pCAL");
*purpose = info_ptr->pcal_purpose; *purpose = info_ptr->pcal_purpose;
@@ -629,7 +660,7 @@ png_get_sCAL(png_structp png_ptr, png_infop info_ptr,
int *unit, double *width, double *height) int *unit, double *width, double *height)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_sCAL)) (info_ptr->valid & PNG_INFO_sCAL))
{ {
*unit = info_ptr->scal_unit; *unit = info_ptr->scal_unit;
*width = info_ptr->scal_pixel_width; *width = info_ptr->scal_pixel_width;
@@ -645,7 +676,7 @@ png_get_sCAL_s(png_structp png_ptr, png_infop info_ptr,
int *unit, png_charpp width, png_charpp height) int *unit, png_charpp width, png_charpp height)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_sCAL)) (info_ptr->valid & PNG_INFO_sCAL))
{ {
*unit = info_ptr->scal_unit; *unit = info_ptr->scal_unit;
*width = info_ptr->scal_s_width; *width = info_ptr->scal_s_width;
@@ -669,16 +700,19 @@ png_get_pHYs(png_structp png_ptr, png_infop info_ptr,
(info_ptr->valid & PNG_INFO_pHYs)) (info_ptr->valid & PNG_INFO_pHYs))
{ {
png_debug1(1, "in %s retrieval function", "pHYs"); png_debug1(1, "in %s retrieval function", "pHYs");
if (res_x != NULL) if (res_x != NULL)
{ {
*res_x = info_ptr->x_pixels_per_unit; *res_x = info_ptr->x_pixels_per_unit;
retval |= PNG_INFO_pHYs; retval |= PNG_INFO_pHYs;
} }
if (res_y != NULL) if (res_y != NULL)
{ {
*res_y = info_ptr->y_pixels_per_unit; *res_y = info_ptr->y_pixels_per_unit;
retval |= PNG_INFO_pHYs; retval |= PNG_INFO_pHYs;
} }
if (unit_type != NULL) if (unit_type != NULL)
{ {
*unit_type = (int)info_ptr->phys_unit_type; *unit_type = (int)info_ptr->phys_unit_type;
@@ -730,10 +764,13 @@ png_get_text(png_structp png_ptr, png_infop info_ptr, png_textp *text_ptr,
png_debug1(1, "in %s retrieval function", png_debug1(1, "in %s retrieval function",
(png_ptr->chunk_name[0] == '\0' ? "text" (png_ptr->chunk_name[0] == '\0' ? "text"
: (png_const_charp)png_ptr->chunk_name)); : (png_const_charp)png_ptr->chunk_name));
if (text_ptr != NULL) if (text_ptr != NULL)
*text_ptr = info_ptr->text; *text_ptr = info_ptr->text;
if (num_text != NULL) if (num_text != NULL)
*num_text = info_ptr->num_text; *num_text = info_ptr->num_text;
return ((png_uint_32)info_ptr->num_text); return ((png_uint_32)info_ptr->num_text);
} }
if (num_text != NULL) if (num_text != NULL)
@@ -773,6 +810,7 @@ png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
*trans = info_ptr->trans; *trans = info_ptr->trans;
retval |= PNG_INFO_tRNS; retval |= PNG_INFO_tRNS;
} }
if (trans_values != NULL) if (trans_values != NULL)
*trans_values = &(info_ptr->trans_values); *trans_values = &(info_ptr->trans_values);
} }
@@ -783,6 +821,7 @@ png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
*trans_values = &(info_ptr->trans_values); *trans_values = &(info_ptr->trans_values);
retval |= PNG_INFO_tRNS; retval |= PNG_INFO_tRNS;
} }
if (trans != NULL) if (trans != NULL)
*trans = NULL; *trans = NULL;
} }
@@ -836,47 +875,47 @@ png_get_compression_buffer_size(png_structp png_ptr)
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
#ifndef PNG_1_0_X #ifndef PNG_1_0_X
/* this function was added to libpng 1.2.0 and should exist by default */ /* This function was added to libpng 1.2.0 and should exist by default */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_asm_flags (png_structp png_ptr) png_get_asm_flags (png_structp png_ptr)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return (png_ptr? 0L: 0L); return (png_ptr? 0L: 0L);
} }
/* this function was added to libpng 1.2.0 and should exist by default */ /* This function was added to libpng 1.2.0 and should exist by default */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_asm_flagmask (int flag_select) png_get_asm_flagmask (int flag_select)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
flag_select=flag_select; flag_select=flag_select;
return 0L; return 0L;
} }
/* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */ /* GRR: could add this: && defined(PNG_MMX_CODE_SUPPORTED) */
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_mmx_flagmask (int flag_select, int *compilerID) png_get_mmx_flagmask (int flag_select, int *compilerID)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
flag_select=flag_select; flag_select=flag_select;
*compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */ *compilerID = -1; /* unknown (i.e., no asm/MMX code compiled) */
return 0L; return 0L;
} }
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
png_byte PNGAPI png_byte PNGAPI
png_get_mmx_bitdepth_threshold (png_structp png_ptr) png_get_mmx_bitdepth_threshold (png_structp png_ptr)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return (png_ptr? 0: 0); return (png_ptr? 0: 0);
} }
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_mmx_rowbytes_threshold (png_structp png_ptr) png_get_mmx_rowbytes_threshold (png_structp png_ptr)
{ {
/* obsolete, to be removed from libpng-1.4.0 */ /* Obsolete, to be removed from libpng-1.4.0 */
return (png_ptr? 0L: 0L); return (png_ptr? 0L: 0L);
} }
#endif /* ?PNG_1_0_X */ #endif /* ?PNG_1_0_X */
src/libs/png/pngmem.c
+48 -40
View File
@@ -1,9 +1,9 @@
/* pngmem.c - stub functions for memory allocation /* pngmem.c - stub functions for memory allocation
* *
* Last changed in libpng 1.2.30 [August 15, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
@@ -20,7 +20,7 @@
/* Borland DOS special memory handler */ /* Borland DOS special memory handler */
#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) #if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__)
/* if you change this, be sure to change the one in png.h also */ /* If you change this, be sure to change the one in png.h also */
/* Allocate memory for a png_struct. The malloc and memset can be replaced /* Allocate memory for a png_struct. The malloc and memset can be replaced
by a single call to calloc() if this is thought to improve performance. */ by a single call to calloc() if this is thought to improve performance. */
@@ -40,11 +40,11 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
png_voidp struct_ptr; png_voidp struct_ptr;
if (type == PNG_STRUCT_INFO) if (type == PNG_STRUCT_INFO)
size = png_sizeof(png_info); size = png_sizeof(png_info);
else if (type == PNG_STRUCT_PNG) else if (type == PNG_STRUCT_PNG)
size = png_sizeof(png_struct); size = png_sizeof(png_struct);
else else
return (png_get_copyright(NULL)); return (png_get_copyright(NULL));
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
if (malloc_fn != NULL) if (malloc_fn != NULL)
@@ -56,7 +56,7 @@ png_create_struct_2(int type, png_malloc_ptr malloc_fn, png_voidp mem_ptr)
} }
else else
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* PNG_USER_MEM_SUPPORTED */
struct_ptr = (png_voidp)farmalloc(size); struct_ptr = (png_voidp)farmalloc(size);
if (struct_ptr != NULL) if (struct_ptr != NULL)
png_memset(struct_ptr, 0, size); png_memset(struct_ptr, 0, size);
return (struct_ptr); return (struct_ptr);
@@ -122,9 +122,9 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
if (png_ptr->malloc_fn != NULL) if (png_ptr->malloc_fn != NULL)
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
else else
ret = (png_malloc_default(png_ptr, size)); ret = (png_malloc_default(png_ptr, size));
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
png_error(png_ptr, "Out of memory!"); png_error(png_ptr, "Out of memory!");
return (ret); return (ret);
@@ -149,12 +149,12 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
#endif #endif
if (size != (size_t)size) if (size != (size_t)size)
ret = NULL; ret = NULL;
else if (size == (png_uint_32)65536L) else if (size == (png_uint_32)65536L)
{ {
if (png_ptr->offset_table == NULL) if (png_ptr->offset_table == NULL)
{ {
/* try to see if we need to do any of this fancy stuff */ /* Try to see if we need to do any of this fancy stuff */
ret = farmalloc(size); ret = farmalloc(size);
if (ret == NULL || ((png_size_t)ret & 0xffff)) if (ret == NULL || ((png_size_t)ret & 0xffff))
{ {
@@ -269,10 +269,10 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
return (ret); return (ret);
} }
/* free a pointer allocated by png_malloc(). In the default /* Free a pointer allocated by png_malloc(). In the default
configuration, png_ptr is not used, but is passed in case it * configuration, png_ptr is not used, but is passed in case it
is needed. If ptr is NULL, return without taking any action. */ * is needed. If ptr is NULL, return without taking any action.
*/
void PNGAPI void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr) png_free(png_structp png_ptr, png_voidp ptr)
{ {
@@ -285,7 +285,8 @@ png_free(png_structp png_ptr, png_voidp ptr)
(*(png_ptr->free_fn))(png_ptr, ptr); (*(png_ptr->free_fn))(png_ptr, ptr);
return; return;
} }
else png_free_default(png_ptr, ptr); else
png_free_default(png_ptr, ptr);
} }
void PNGAPI void PNGAPI
@@ -293,7 +294,8 @@ png_free_default(png_structp png_ptr, png_voidp ptr)
{ {
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* PNG_USER_MEM_SUPPORTED */
if (png_ptr == NULL || ptr == NULL) return; if (png_ptr == NULL || ptr == NULL)
return;
if (png_ptr->offset_table != NULL) if (png_ptr->offset_table != NULL)
{ {
@@ -420,10 +422,12 @@ png_destroy_struct_2(png_voidp struct_ptr, png_free_ptr free_fn,
} }
/* Allocate memory. For reasonable files, size should never exceed /* Allocate memory. For reasonable files, size should never exceed
64K. However, zlib may allocate more then 64K if you don't tell * 64K. However, zlib may allocate more then 64K if you don't tell
it not to. See zconf.h and png.h for more information. zlib does * it not to. See zconf.h and png.h for more information. zlib does
need to allocate exactly 64K, so whatever you call here must * need to allocate exactly 64K, so whatever you call here must
have the ability to do that. */ * have the ability to do that.
*/
png_voidp PNGAPI png_voidp PNGAPI
png_malloc(png_structp png_ptr, png_uint_32 size) png_malloc(png_structp png_ptr, png_uint_32 size)
@@ -435,9 +439,9 @@ png_malloc(png_structp png_ptr, png_uint_32 size)
return (NULL); return (NULL);
if (png_ptr->malloc_fn != NULL) if (png_ptr->malloc_fn != NULL)
ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size)); ret = ((png_voidp)(*(png_ptr->malloc_fn))(png_ptr, (png_size_t)size));
else else
ret = (png_malloc_default(png_ptr, size)); ret = (png_malloc_default(png_ptr, size));
if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0) if (ret == NULL && (png_ptr->flags&PNG_FLAG_MALLOC_NULL_MEM_OK) == 0)
png_error(png_ptr, "Out of Memory!"); png_error(png_ptr, "Out of Memory!");
return (ret); return (ret);
@@ -464,23 +468,23 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
} }
#endif #endif
/* Check for overflow */ /* Check for overflow */
#if defined(__TURBOC__) && !defined(__FLAT__) #if defined(__TURBOC__) && !defined(__FLAT__)
if (size != (unsigned long)size) if (size != (unsigned long)size)
ret = NULL; ret = NULL;
else else
ret = farmalloc(size); ret = farmalloc(size);
#else #else
# if defined(_MSC_VER) && defined(MAXSEG_64K) # if defined(_MSC_VER) && defined(MAXSEG_64K)
if (size != (unsigned long)size) if (size != (unsigned long)size)
ret = NULL; ret = NULL;
else else
ret = halloc(size, 1); ret = halloc(size, 1);
# else # else
if (size != (size_t)size) if (size != (size_t)size)
ret = NULL; ret = NULL;
else else
ret = malloc((size_t)size); ret = malloc((size_t)size);
# endif # endif
#endif #endif
@@ -493,7 +497,8 @@ png_malloc_default(png_structp png_ptr, png_uint_32 size)
} }
/* Free a pointer allocated by png_malloc(). If ptr is NULL, return /* Free a pointer allocated by png_malloc(). If ptr is NULL, return
without taking any action. */ * without taking any action.
*/
void PNGAPI void PNGAPI
png_free(png_structp png_ptr, png_voidp ptr) png_free(png_structp png_ptr, png_voidp ptr)
{ {
@@ -506,7 +511,8 @@ png_free(png_structp png_ptr, png_voidp ptr)
(*(png_ptr->free_fn))(png_ptr, ptr); (*(png_ptr->free_fn))(png_ptr, ptr);
return; return;
} }
else png_free_default(png_ptr, ptr); else
png_free_default(png_ptr, ptr);
} }
void PNGAPI void PNGAPI
png_free_default(png_structp png_ptr, png_voidp ptr) png_free_default(png_structp png_ptr, png_voidp ptr)
@@ -542,7 +548,8 @@ png_malloc_warn(png_structp png_ptr, png_uint_32 size)
{ {
png_voidp ptr; png_voidp ptr;
png_uint_32 save_flags; png_uint_32 save_flags;
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
save_flags = png_ptr->flags; save_flags = png_ptr->flags;
png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK; png_ptr->flags|=PNG_FLAG_MALLOC_NULL_MEM_OK;
@@ -602,7 +609,8 @@ png_set_mem_fn(png_structp png_ptr, png_voidp mem_ptr, png_malloc_ptr
png_voidp PNGAPI png_voidp PNGAPI
png_get_mem_ptr(png_structp png_ptr) png_get_mem_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
return ((png_voidp)png_ptr->mem_ptr); return ((png_voidp)png_ptr->mem_ptr);
} }
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* PNG_USER_MEM_SUPPORTED */
src/libs/png/pngpread.c
+174 -44
View File
@@ -1,9 +1,9 @@
/* pngpread.c - read a png file in push mode /* pngpread.c - read a png file in push mode
* *
* Last changed in libpng 1.2.32 [September 18, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@@ -12,7 +12,7 @@
#include "png.h" #include "png.h"
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED #ifdef PNG_PROGRESSIVE_READ_SUPPORTED
/* push model modes */ /* Push model modes */
#define PNG_READ_SIG_MODE 0 #define PNG_READ_SIG_MODE 0
#define PNG_READ_CHUNK_MODE 1 #define PNG_READ_CHUNK_MODE 1
#define PNG_READ_IDAT_MODE 2 #define PNG_READ_IDAT_MODE 2
@@ -27,7 +27,9 @@ void PNGAPI
png_process_data(png_structp png_ptr, png_infop info_ptr, png_process_data(png_structp png_ptr, png_infop info_ptr,
png_bytep buffer, png_size_t buffer_size) png_bytep buffer, png_size_t buffer_size)
{ {
if (png_ptr == NULL || info_ptr == NULL) return; if (png_ptr == NULL || info_ptr == NULL)
return;
png_push_restore_buffer(png_ptr, buffer, buffer_size); png_push_restore_buffer(png_ptr, buffer, buffer_size);
while (png_ptr->buffer_size) while (png_ptr->buffer_size)
@@ -42,7 +44,9 @@ png_process_data(png_structp png_ptr, png_infop info_ptr,
void /* PRIVATE */ void /* PRIVATE */
png_process_some_data(png_structp png_ptr, png_infop info_ptr) png_process_some_data(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
switch (png_ptr->process_mode) switch (png_ptr->process_mode)
{ {
case PNG_READ_SIG_MODE: case PNG_READ_SIG_MODE:
@@ -50,22 +54,26 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
png_push_read_sig(png_ptr, info_ptr); png_push_read_sig(png_ptr, info_ptr);
break; break;
} }
case PNG_READ_CHUNK_MODE: case PNG_READ_CHUNK_MODE:
{ {
png_push_read_chunk(png_ptr, info_ptr); png_push_read_chunk(png_ptr, info_ptr);
break; break;
} }
case PNG_READ_IDAT_MODE: case PNG_READ_IDAT_MODE:
{ {
png_push_read_IDAT(png_ptr); png_push_read_IDAT(png_ptr);
break; break;
} }
#if defined(PNG_READ_tEXt_SUPPORTED) #if defined(PNG_READ_tEXt_SUPPORTED)
case PNG_READ_tEXt_MODE: case PNG_READ_tEXt_MODE:
{ {
png_push_read_tEXt(png_ptr, info_ptr); png_push_read_tEXt(png_ptr, info_ptr);
break; break;
} }
#endif #endif
#if defined(PNG_READ_zTXt_SUPPORTED) #if defined(PNG_READ_zTXt_SUPPORTED)
case PNG_READ_zTXt_MODE: case PNG_READ_zTXt_MODE:
@@ -73,6 +81,7 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
png_push_read_zTXt(png_ptr, info_ptr); png_push_read_zTXt(png_ptr, info_ptr);
break; break;
} }
#endif #endif
#if defined(PNG_READ_iTXt_SUPPORTED) #if defined(PNG_READ_iTXt_SUPPORTED)
case PNG_READ_iTXt_MODE: case PNG_READ_iTXt_MODE:
@@ -80,12 +89,14 @@ png_process_some_data(png_structp png_ptr, png_infop info_ptr)
png_push_read_iTXt(png_ptr, info_ptr); png_push_read_iTXt(png_ptr, info_ptr);
break; break;
} }
#endif #endif
case PNG_SKIP_MODE: case PNG_SKIP_MODE:
{ {
png_push_crc_finish(png_ptr); png_push_crc_finish(png_ptr);
break; break;
} }
default: default:
{ {
png_ptr->buffer_size = 0; png_ptr->buffer_size = 0;
@@ -224,13 +235,16 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr->push_length != 13) if (png_ptr->push_length != 13)
png_error(png_ptr, "Invalid IHDR length"); png_error(png_ptr, "Invalid IHDR length");
if (png_ptr->push_length + 4 > png_ptr->buffer_size) if (png_ptr->push_length + 4 > png_ptr->buffer_size)
{ {
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length); png_handle_IHDR(png_ptr, info_ptr, png_ptr->push_length);
} }
else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
{ {
if (png_ptr->push_length + 4 > png_ptr->buffer_size) if (png_ptr->push_length + 4 > png_ptr->buffer_size)
@@ -238,11 +252,13 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length); png_handle_IEND(png_ptr, info_ptr, png_ptr->push_length);
png_ptr->process_mode = PNG_READ_DONE_MODE; png_ptr->process_mode = PNG_READ_DONE_MODE;
png_push_have_end(png_ptr, info_ptr); png_push_have_end(png_ptr, info_ptr);
} }
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name)) else if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name))
{ {
@@ -251,20 +267,26 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
png_ptr->mode |= PNG_HAVE_IDAT; png_ptr->mode |= PNG_HAVE_IDAT;
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length); png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length);
if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
png_ptr->mode |= PNG_HAVE_PLTE; png_ptr->mode |= PNG_HAVE_PLTE;
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
{ {
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before IDAT"); png_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) !(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
} }
} }
#endif #endif
else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4))
{ {
@@ -275,23 +297,26 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
} }
png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length); png_handle_PLTE(png_ptr, info_ptr, png_ptr->push_length);
} }
else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
{ {
/* If we reach an IDAT chunk, this means we have read all of the /* If we reach an IDAT chunk, this means we have read all of the
* header chunks, and we can start reading the image (or if this * header chunks, and we can start reading the image (or if this
* is called after the image has been read - we have an error). * is called after the image has been read - we have an error).
*/ */
if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before IDAT"); if (!(png_ptr->mode & PNG_HAVE_IHDR))
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && png_error(png_ptr, "Missing IHDR before IDAT");
!(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT"); else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT");
if (png_ptr->mode & PNG_HAVE_IDAT) if (png_ptr->mode & PNG_HAVE_IDAT)
{ {
if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) if (!(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT))
if (png_ptr->push_length == 0) if (png_ptr->push_length == 0)
return; return;
if (png_ptr->mode & PNG_AFTER_IDAT) if (png_ptr->mode & PNG_AFTER_IDAT)
png_error(png_ptr, "Too many IDAT's found"); png_error(png_ptr, "Too many IDAT's found");
@@ -305,6 +330,7 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_ptr->zstream.next_out = png_ptr->row_buf; png_ptr->zstream.next_out = png_ptr->row_buf;
return; return;
} }
#if defined(PNG_READ_gAMA_SUPPORTED) #if defined(PNG_READ_gAMA_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_gAMA, 4))
{ {
@@ -313,8 +339,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length); png_handle_gAMA(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sBIT_SUPPORTED) #if defined(PNG_READ_sBIT_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sBIT, 4))
@@ -324,8 +352,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length); png_handle_sBIT(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_cHRM_SUPPORTED) #if defined(PNG_READ_cHRM_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_cHRM, 4))
@@ -335,8 +365,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length); png_handle_cHRM(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sRGB_SUPPORTED) #if defined(PNG_READ_sRGB_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sRGB, 4))
@@ -346,8 +378,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length); png_handle_sRGB(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_iCCP_SUPPORTED) #if defined(PNG_READ_iCCP_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_iCCP, 4))
@@ -357,8 +391,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length); png_handle_iCCP(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sPLT_SUPPORTED) #if defined(PNG_READ_sPLT_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sPLT, 4))
@@ -368,8 +404,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length); png_handle_sPLT(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_tRNS_SUPPORTED) #if defined(PNG_READ_tRNS_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_tRNS, 4))
@@ -379,8 +417,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length); png_handle_tRNS(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_bKGD_SUPPORTED) #if defined(PNG_READ_bKGD_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_bKGD, 4))
@@ -390,8 +430,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length); png_handle_bKGD(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_hIST_SUPPORTED) #if defined(PNG_READ_hIST_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_hIST, 4))
@@ -401,8 +443,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length); png_handle_hIST(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_pHYs_SUPPORTED) #if defined(PNG_READ_pHYs_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_pHYs, 4))
@@ -412,8 +456,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length); png_handle_pHYs(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_oFFs_SUPPORTED) #if defined(PNG_READ_oFFs_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_oFFs, 4))
@@ -423,9 +469,11 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length); png_handle_oFFs(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_pCAL_SUPPORTED) #if defined(PNG_READ_pCAL_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_pCAL, 4))
{ {
@@ -434,8 +482,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length); png_handle_pCAL(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_sCAL_SUPPORTED) #if defined(PNG_READ_sCAL_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_sCAL, 4))
@@ -445,8 +495,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length); png_handle_sCAL(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_tIME_SUPPORTED) #if defined(PNG_READ_tIME_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_tIME, 4))
@@ -456,8 +508,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length); png_handle_tIME(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_tEXt_SUPPORTED) #if defined(PNG_READ_tEXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_tEXt, 4))
@@ -467,8 +521,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length); png_push_handle_tEXt(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_zTXt_SUPPORTED) #if defined(PNG_READ_zTXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_zTXt, 4))
@@ -478,8 +534,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length); png_push_handle_zTXt(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
#if defined(PNG_READ_iTXt_SUPPORTED) #if defined(PNG_READ_iTXt_SUPPORTED)
else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4))
@@ -489,8 +547,10 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_push_save_buffer(png_ptr); png_push_save_buffer(png_ptr);
return; return;
} }
png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length);
} }
#endif #endif
else else
{ {
@@ -565,7 +625,9 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
{ {
png_bytep ptr; png_bytep ptr;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
ptr = buffer; ptr = buffer;
if (png_ptr->save_buffer_size) if (png_ptr->save_buffer_size)
{ {
@@ -589,6 +651,7 @@ png_push_fill_buffer(png_structp png_ptr, png_bytep buffer, png_size_t length)
if (length < png_ptr->current_buffer_size) if (length < png_ptr->current_buffer_size)
save_size = length; save_size = length;
else else
save_size = png_ptr->current_buffer_size; save_size = png_ptr->current_buffer_size;
@@ -629,6 +692,7 @@ png_push_save_buffer(png_structp png_ptr)
{ {
png_error(png_ptr, "Potential overflow of save_buffer"); png_error(png_ptr, "Potential overflow of save_buffer");
} }
new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
old_buffer = png_ptr->save_buffer; old_buffer = png_ptr->save_buffer;
png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr, png_ptr->save_buffer = (png_bytep)png_malloc(png_ptr,
@@ -697,7 +761,8 @@ png_push_read_IDAT(png_structp png_ptr)
if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size) if (png_ptr->idat_size < (png_uint_32)png_ptr->save_buffer_size)
{ {
save_size = (png_size_t)png_ptr->idat_size; save_size = (png_size_t)png_ptr->idat_size;
/* check for overflow */
/* Check for overflow */
if ((png_uint_32)save_size != png_ptr->idat_size) if ((png_uint_32)save_size != png_ptr->idat_size)
png_error(png_ptr, "save_size overflowed in pngpread"); png_error(png_ptr, "save_size overflowed in pngpread");
} }
@@ -705,8 +770,10 @@ png_push_read_IDAT(png_structp png_ptr)
save_size = png_ptr->save_buffer_size; save_size = png_ptr->save_buffer_size;
png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size); png_calculate_crc(png_ptr, png_ptr->save_buffer_ptr, save_size);
if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED))
png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size); png_process_IDAT_data(png_ptr, png_ptr->save_buffer_ptr, save_size);
png_ptr->idat_size -= save_size; png_ptr->idat_size -= save_size;
png_ptr->buffer_size -= save_size; png_ptr->buffer_size -= save_size;
png_ptr->save_buffer_size -= save_size; png_ptr->save_buffer_size -= save_size;
@@ -719,7 +786,8 @@ png_push_read_IDAT(png_structp png_ptr)
if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size) if (png_ptr->idat_size < (png_uint_32)png_ptr->current_buffer_size)
{ {
save_size = (png_size_t)png_ptr->idat_size; save_size = (png_size_t)png_ptr->idat_size;
/* check for overflow */
/* Check for overflow */
if ((png_uint_32)save_size != png_ptr->idat_size) if ((png_uint_32)save_size != png_ptr->idat_size)
png_error(png_ptr, "save_size overflowed in pngpread"); png_error(png_ptr, "save_size overflowed in pngpread");
} }
@@ -769,6 +837,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
{ {
if (png_ptr->zstream.avail_in) if (png_ptr->zstream.avail_in)
png_error(png_ptr, "Extra compressed data"); png_error(png_ptr, "Extra compressed data");
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
png_push_process_row(png_ptr); png_push_process_row(png_ptr);
@@ -780,6 +849,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
} }
else if (ret == Z_BUF_ERROR) else if (ret == Z_BUF_ERROR)
break; break;
else else
png_error(png_ptr, "Decompression Error"); png_error(png_ptr, "Decompression Error");
} }
@@ -801,6 +871,7 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes;
png_ptr->zstream.next_out = png_ptr->row_buf; png_ptr->zstream.next_out = png_ptr->row_buf;
} }
else else
break; break;
} }
@@ -829,7 +900,7 @@ png_push_process_row(png_structp png_ptr)
png_do_read_transformations(png_ptr); png_do_read_transformations(png_ptr);
#if defined(PNG_READ_INTERLACING_SUPPORTED) #if defined(PNG_READ_INTERLACING_SUPPORTED)
/* blow up interlaced rows to full size */ /* Blow up interlaced rows to full size */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
@@ -847,9 +918,10 @@ png_push_process_row(png_structp png_ptr)
for (i = 0; i < 8 && png_ptr->pass == 0; i++) for (i = 0; i < 8 && png_ptr->pass == 0; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); /* updates png_ptr->pass */ png_read_push_finish_row(png_ptr); /* Updates png_ptr->pass */
} }
if (png_ptr->pass == 2) /* pass 1 might be empty */
if (png_ptr->pass == 2) /* Pass 1 might be empty */
{ {
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
@@ -857,6 +929,7 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
if (png_ptr->pass == 4 && png_ptr->height <= 4) if (png_ptr->pass == 4 && png_ptr->height <= 4)
{ {
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
@@ -865,13 +938,16 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
if (png_ptr->pass == 6 && png_ptr->height <= 4) if (png_ptr->pass == 6 && png_ptr->height <= 4)
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
break; break;
} }
case 1: case 1:
{ {
int i; int i;
@@ -880,7 +956,8 @@ png_push_process_row(png_structp png_ptr)
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 2) /* skip top 4 generated rows */
if (png_ptr->pass == 2) /* Skip top 4 generated rows */
{ {
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
@@ -888,22 +965,27 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
break; break;
} }
case 2: case 2:
{ {
int i; int i;
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
for (i = 0; i < 4 && png_ptr->pass == 2; i++) for (i = 0; i < 4 && png_ptr->pass == 2; i++)
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 4) /* pass 3 might be empty */
if (png_ptr->pass == 4) /* Pass 3 might be empty */
{ {
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
@@ -911,17 +993,21 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
break; break;
} }
case 3: case 3:
{ {
int i; int i;
for (i = 0; i < 4 && png_ptr->pass == 3; i++) for (i = 0; i < 4 && png_ptr->pass == 3; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 4) /* skip top two generated rows */
if (png_ptr->pass == 4) /* Skip top two generated rows */
{ {
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
@@ -929,49 +1015,61 @@ png_push_process_row(png_structp png_ptr)
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
} }
break; break;
} }
case 4: case 4:
{ {
int i; int i;
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
for (i = 0; i < 2 && png_ptr->pass == 4; i++) for (i = 0; i < 2 && png_ptr->pass == 4; i++)
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 6) /* pass 5 might be empty */
if (png_ptr->pass == 6) /* Pass 5 might be empty */
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
break; break;
} }
case 5: case 5:
{ {
int i; int i;
for (i = 0; i < 2 && png_ptr->pass == 5; i++) for (i = 0; i < 2 && png_ptr->pass == 5; i++)
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
if (png_ptr->pass == 6) /* skip top generated row */
if (png_ptr->pass == 6) /* Skip top generated row */
{ {
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
break; break;
} }
case 6: case 6:
{ {
png_push_have_row(png_ptr, png_ptr->row_buf + 1); png_push_have_row(png_ptr, png_ptr->row_buf + 1);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
if (png_ptr->pass != 6) if (png_ptr->pass != 6)
break; break;
png_push_have_row(png_ptr, png_bytep_NULL); png_push_have_row(png_ptr, png_bytep_NULL);
png_read_push_finish_row(png_ptr); png_read_push_finish_row(png_ptr);
} }
@@ -989,18 +1087,18 @@ void /* PRIVATE */
png_read_push_finish_row(png_structp png_ptr) png_read_push_finish_row(png_structp png_ptr)
{ {
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1};
/* offset to next interlace block in the y direction */ /* Offset to next interlace block in the y direction */
PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2};
/* Height of interlace block. This is not currently used - if you need /* Height of interlace block. This is not currently used - if you need
@@ -1013,6 +1111,7 @@ png_read_push_finish_row(png_structp png_ptr)
if (png_ptr->row_number < png_ptr->num_rows) if (png_ptr->row_number < png_ptr->num_rows)
return; return;
#if defined(PNG_READ_INTERLACING_SUPPORTED)
if (png_ptr->interlaced) if (png_ptr->interlaced)
{ {
png_ptr->row_number = 0; png_ptr->row_number = 0;
@@ -1028,6 +1127,7 @@ png_read_push_finish_row(png_structp png_ptr)
if (png_ptr->pass > 7) if (png_ptr->pass > 7)
png_ptr->pass--; png_ptr->pass--;
if (png_ptr->pass >= 7) if (png_ptr->pass >= 7)
break; break;
@@ -1049,6 +1149,7 @@ png_read_push_finish_row(png_structp png_ptr)
} while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0); } while (png_ptr->iwidth == 0 || png_ptr->num_rows == 0);
} }
#endif /* PNG_READ_INTERLACING_SUPPORTED */
} }
#if defined(PNG_READ_tEXt_SUPPORTED) #if defined(PNG_READ_tEXt_SUPPORTED)
@@ -1059,7 +1160,7 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
png_error(png_ptr, "Out of place tEXt"); png_error(png_ptr, "Out of place tEXt");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
@@ -1091,8 +1192,10 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
if (png_ptr->buffer_size < png_ptr->current_text_left) if (png_ptr->buffer_size < png_ptr->current_text_left)
text_size = png_ptr->buffer_size; text_size = png_ptr->buffer_size;
else else
text_size = png_ptr->current_text_left; text_size = png_ptr->current_text_left;
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size; png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size; png_ptr->current_text_ptr += text_size;
@@ -1120,7 +1223,7 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
key = png_ptr->current_text; key = png_ptr->current_text;
for (text = key; *text; text++) for (text = key; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
if (text < key + png_ptr->current_text_size) if (text < key + png_ptr->current_text_size)
text++; text++;
@@ -1155,7 +1258,7 @@ png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
png_error(png_ptr, "Out of place zTXt"); png_error(png_ptr, "Out of place zTXt");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
@@ -1189,8 +1292,10 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left) if (png_ptr->buffer_size < (png_uint_32)png_ptr->current_text_left)
text_size = png_ptr->buffer_size; text_size = png_ptr->buffer_size;
else else
text_size = png_ptr->current_text_left; text_size = png_ptr->current_text_left;
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size; png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size; png_ptr->current_text_ptr += text_size;
@@ -1214,7 +1319,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
key = png_ptr->current_text; key = png_ptr->current_text;
for (text = key; *text; text++) for (text = key; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
/* zTXt can't have zero text */ /* zTXt can't have zero text */
if (text >= key + png_ptr->current_text_size) if (text >= key + png_ptr->current_text_size)
@@ -1226,7 +1331,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
text++; text++;
if (*text != PNG_TEXT_COMPRESSION_zTXt) /* check compression byte */ if (*text != PNG_TEXT_COMPRESSION_zTXt) /* Check compression byte */
{ {
png_ptr->current_text = NULL; png_ptr->current_text = NULL;
png_free(png_ptr, key); png_free(png_ptr, key);
@@ -1265,11 +1370,15 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
text = (png_charp)png_malloc(png_ptr, text = (png_charp)png_malloc(png_ptr,
(png_uint_32)(png_ptr->zbuf_size (png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + key_size + 1)); - png_ptr->zstream.avail_out + key_size + 1));
png_memcpy(text + key_size, png_ptr->zbuf, png_memcpy(text + key_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
png_memcpy(text, key, key_size); png_memcpy(text, key, key_size);
text_size = key_size + png_ptr->zbuf_size - text_size = key_size + png_ptr->zbuf_size -
png_ptr->zstream.avail_out; png_ptr->zstream.avail_out;
*(text + text_size) = '\0'; *(text + text_size) = '\0';
} }
else else
@@ -1280,10 +1389,13 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
text = (png_charp)png_malloc(png_ptr, text_size + text = (png_charp)png_malloc(png_ptr, text_size +
(png_uint_32)(png_ptr->zbuf_size (png_uint_32)(png_ptr->zbuf_size
- png_ptr->zstream.avail_out + 1)); - png_ptr->zstream.avail_out + 1));
png_memcpy(text, tmp, text_size); png_memcpy(text, tmp, text_size);
png_free(png_ptr, tmp); png_free(png_ptr, tmp);
png_memcpy(text + text_size, png_ptr->zbuf, png_memcpy(text + text_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
*(text + text_size) = '\0'; *(text + text_size) = '\0';
} }
@@ -1347,7 +1459,7 @@ png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
png_error(png_ptr, "Out of place iTXt"); png_error(png_ptr, "Out of place iTXt");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
@@ -1380,8 +1492,10 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
if (png_ptr->buffer_size < png_ptr->current_text_left) if (png_ptr->buffer_size < png_ptr->current_text_left)
text_size = png_ptr->buffer_size; text_size = png_ptr->buffer_size;
else else
text_size = png_ptr->current_text_left; text_size = png_ptr->current_text_left;
png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size); png_crc_read(png_ptr, (png_bytep)png_ptr->current_text_ptr, text_size);
png_ptr->current_text_left -= text_size; png_ptr->current_text_left -= text_size;
png_ptr->current_text_ptr += text_size; png_ptr->current_text_ptr += text_size;
@@ -1412,23 +1526,25 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
key = png_ptr->current_text; key = png_ptr->current_text;
for (lang = key; *lang; lang++) for (lang = key; *lang; lang++)
/* empty loop */ ; /* Empty loop */ ;
if (lang < key + png_ptr->current_text_size - 3) if (lang < key + png_ptr->current_text_size - 3)
lang++; lang++;
comp_flag = *lang++; comp_flag = *lang++;
lang++; /* skip comp_type, always zero */ lang++; /* Skip comp_type, always zero */
for (lang_key = lang; *lang_key; lang_key++) for (lang_key = lang; *lang_key; lang_key++)
/* empty loop */ ; /* Empty loop */ ;
lang_key++; /* skip NUL separator */
lang_key++; /* Skip NUL separator */
text=lang_key; text=lang_key;
if (lang_key < key + png_ptr->current_text_size - 1) if (lang_key < key + png_ptr->current_text_size - 1)
{ {
for (; *text; text++) for (; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
} }
if (text < key + png_ptr->current_text_size) if (text < key + png_ptr->current_text_size)
@@ -1436,6 +1552,7 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
text_ptr = (png_textp)png_malloc(png_ptr, text_ptr = (png_textp)png_malloc(png_ptr,
(png_uint_32)png_sizeof(png_text)); (png_uint_32)png_sizeof(png_text));
text_ptr->compression = comp_flag + 2; text_ptr->compression = comp_flag + 2;
text_ptr->key = key; text_ptr->key = key;
text_ptr->lang = lang; text_ptr->lang = lang;
@@ -1477,7 +1594,7 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
#endif #endif
png_chunk_error(png_ptr, "unknown critical chunk"); png_chunk_error(png_ptr, "unknown critical chunk");
info_ptr = info_ptr; /* to quiet some compiler warnings */ info_ptr = info_ptr; /* To quiet some compiler warnings */
} }
#if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
@@ -1498,23 +1615,28 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
= '\0'; = '\0';
png_ptr->unknown_chunk.size = (png_size_t)length; png_ptr->unknown_chunk.size = (png_size_t)length;
if (length == 0) if (length == 0)
png_ptr->unknown_chunk.data = NULL; png_ptr->unknown_chunk.data = NULL;
else else
{ {
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
(png_uint_32)length); (png_uint_32)length);
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
} }
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
if (png_ptr->read_user_chunk_fn != NULL) if (png_ptr->read_user_chunk_fn != NULL)
{ {
/* callback to user unknown chunk handler */ /* Callback to user unknown chunk handler */
int ret; int ret;
ret = (*(png_ptr->read_user_chunk_fn)) ret = (*(png_ptr->read_user_chunk_fn))
(png_ptr, &png_ptr->unknown_chunk); (png_ptr, &png_ptr->unknown_chunk);
if (ret < 0) if (ret < 0)
png_chunk_error(png_ptr, "error in user chunk"); png_chunk_error(png_ptr, "error in user chunk");
if (ret == 0) if (ret == 0)
{ {
if (!(png_ptr->chunk_name[0] & 0x20)) if (!(png_ptr->chunk_name[0] & 0x20))
@@ -1525,12 +1647,14 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
&png_ptr->unknown_chunk, 1); &png_ptr->unknown_chunk, 1);
} }
} }
else else
#endif #endif
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
png_free(png_ptr, png_ptr->unknown_chunk.data); png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr->unknown_chunk.data = NULL; png_ptr->unknown_chunk.data = NULL;
} }
else else
#endif #endif
skip=length; skip=length;
@@ -1567,7 +1691,9 @@ png_progressive_combine_row (png_structp png_ptr,
PNG_CONST int FARDATA png_pass_dsp_mask[7] = PNG_CONST int FARDATA png_pass_dsp_mask[7] =
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
#endif #endif
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */ if (new_row != NULL) /* new_row must == png_ptr->row_buf here. */
png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]); png_combine_row(png_ptr, old_row, png_pass_dsp_mask[png_ptr->pass]);
} }
@@ -1577,7 +1703,9 @@ png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
png_progressive_end_ptr end_fn) png_progressive_end_ptr end_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->info_fn = info_fn; png_ptr->info_fn = info_fn;
png_ptr->row_fn = row_fn; png_ptr->row_fn = row_fn;
png_ptr->end_fn = end_fn; png_ptr->end_fn = end_fn;
@@ -1588,7 +1716,9 @@ png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
png_voidp PNGAPI png_voidp PNGAPI
png_get_progressive_ptr(png_structp png_ptr) png_get_progressive_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
return png_ptr->io_ptr; return png_ptr->io_ptr;
} }
#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ #endif /* PNG_PROGRESSIVE_READ_SUPPORTED */
src/libs/png/pngread.c
+60 -49
View File
@@ -1,7 +1,7 @@
/* pngread.c - read a PNG file /* pngread.c - read a PNG file
* *
* Last changed in libpng 1.2.35 [February 14, 2009] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -57,7 +57,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
if (png_ptr == NULL) if (png_ptr == NULL)
return (NULL); return (NULL);
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
@@ -137,7 +137,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
} }
} }
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@@ -192,7 +192,8 @@ png_read_init_2(png_structp png_ptr, png_const_charp user_png_ver,
png_size_t png_struct_size, png_size_t png_info_size) png_size_t png_struct_size, png_size_t png_info_size)
{ {
/* We only come here via pre-1.0.12-compiled applications */ /* We only come here via pre-1.0.12-compiled applications */
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) #if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
if (png_sizeof(png_struct) > png_struct_size || if (png_sizeof(png_struct) > png_struct_size ||
png_sizeof(png_info) > png_info_size) png_sizeof(png_info) > png_info_size)
@@ -246,7 +247,8 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
png_structp png_ptr=*ptr_ptr; png_structp png_ptr=*ptr_ptr;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
do do
{ {
@@ -266,7 +268,7 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
png_debug(1, "in png_read_init_3"); png_debug(1, "in png_read_init_3");
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* save jump buffer and error functions */ /* Save jump buffer and error functions */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
#endif #endif
@@ -277,21 +279,21 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
png_ptr = *ptr_ptr; png_ptr = *ptr_ptr;
} }
/* reset all variables to 0 */ /* Reset all variables to 0 */
png_memset(png_ptr, 0, png_sizeof(png_struct)); png_memset(png_ptr, 0, png_sizeof(png_struct));
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* restore jump buffer */ /* Restore jump buffer */
png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
#endif #endif
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
#endif #endif
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@@ -326,7 +328,8 @@ png_read_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
void PNGAPI void PNGAPI
png_read_info(png_structp png_ptr, png_infop info_ptr) png_read_info(png_structp png_ptr, png_infop info_ptr)
{ {
if (png_ptr == NULL || info_ptr == NULL) return; if (png_ptr == NULL || info_ptr == NULL)
return;
png_debug(1, "in png_read_info"); png_debug(1, "in png_read_info");
/* If we haven't checked all of the PNG signature bytes, do so now. */ /* If we haven't checked all of the PNG signature bytes, do so now. */
if (png_ptr->sig_bytes < 8) if (png_ptr->sig_bytes < 8)
@@ -529,12 +532,13 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
} }
#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
/* optional call to update the users info_ptr structure */ /* Optional call to update the users info_ptr structure */
void PNGAPI void PNGAPI
png_read_update_info(png_structp png_ptr, png_infop info_ptr) png_read_update_info(png_structp png_ptr, png_infop info_ptr)
{ {
png_debug(1, "in png_read_update_info"); png_debug(1, "in png_read_update_info");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
else else
@@ -553,7 +557,8 @@ void PNGAPI
png_start_read_image(png_structp png_ptr) png_start_read_image(png_structp png_ptr)
{ {
png_debug(1, "in png_start_read_image"); png_debug(1, "in png_start_read_image");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
} }
@@ -570,14 +575,15 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
#endif #endif
int ret; int ret;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_debug2(1, "in png_read_row (row %lu, pass %d)", png_debug2(1, "in png_read_row (row %lu, pass %d)",
png_ptr->row_number, png_ptr->pass); png_ptr->row_number, png_ptr->pass);
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
if (png_ptr->row_number == 0 && png_ptr->pass == 0) if (png_ptr->row_number == 0 && png_ptr->pass == 0)
{ {
/* check for transforms that have been set but were defined out */ /* Check for transforms that have been set but were defined out */
#if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED) #if defined(PNG_WRITE_INVERT_SUPPORTED) && !defined(PNG_READ_INVERT_SUPPORTED)
if (png_ptr->transformations & PNG_INVERT_MONO) if (png_ptr->transformations & PNG_INVERT_MONO)
png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_READ_INVERT_SUPPORTED is not defined.");
@@ -609,7 +615,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
} }
#if defined(PNG_READ_INTERLACING_SUPPORTED) #if defined(PNG_READ_INTERLACING_SUPPORTED)
/* if interlaced and we do not need a new row, combine row and return */ /* If interlaced and we do not need a new row, combine row and return */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
{ {
switch (png_ptr->pass) switch (png_ptr->pass)
@@ -756,15 +762,15 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
png_do_read_transformations(png_ptr); png_do_read_transformations(png_ptr);
#if defined(PNG_READ_INTERLACING_SUPPORTED) #if defined(PNG_READ_INTERLACING_SUPPORTED)
/* blow up interlaced rows to full size */ /* Blow up interlaced rows to full size */
if (png_ptr->interlaced && if (png_ptr->interlaced &&
(png_ptr->transformations & PNG_INTERLACE)) (png_ptr->transformations & PNG_INTERLACE))
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
/* old interface (pre-1.0.9): /* Old interface (pre-1.0.9):
png_do_read_interlace(&(png_ptr->row_info), * png_do_read_interlace(&(png_ptr->row_info),
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); * png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
*/ */
png_do_read_interlace(png_ptr); png_do_read_interlace(png_ptr);
if (dsp_row != NULL) if (dsp_row != NULL)
@@ -823,7 +829,8 @@ png_read_rows(png_structp png_ptr, png_bytepp row,
png_bytepp dp; png_bytepp dp;
png_debug(1, "in png_read_rows"); png_debug(1, "in png_read_rows");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
rp = row; rp = row;
dp = display_row; dp = display_row;
if (rp != NULL && dp != NULL) if (rp != NULL && dp != NULL)
@@ -872,7 +879,8 @@ png_read_image(png_structp png_ptr, png_bytepp image)
png_bytepp rp; png_bytepp rp;
png_debug(1, "in png_read_image"); png_debug(1, "in png_read_image");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
pass = png_set_interlace_handling(png_ptr); pass = png_set_interlace_handling(png_ptr);
@@ -908,7 +916,8 @@ void PNGAPI
png_read_end(png_structp png_ptr, png_infop info_ptr) png_read_end(png_structp png_ptr, png_infop info_ptr)
{ {
png_debug(1, "in png_read_end"); png_debug(1, "in png_read_end");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */
do do
@@ -1075,7 +1084,7 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
} }
#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
/* free all memory used by the read */ /* Free all memory used by the read */
void PNGAPI void PNGAPI
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
png_infopp end_info_ptr_ptr) png_infopp end_info_ptr_ptr)
@@ -1147,7 +1156,7 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
} }
} }
/* free all memory used by the read (old method) */ /* Free all memory used by the read (old method) */
void /* PRIVATE */ void /* PRIVATE */
png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr) png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr)
{ {
@@ -1296,7 +1305,8 @@ png_read_destroy(png_structp png_ptr, png_infop info_ptr, png_infop end_info_ptr
void PNGAPI void PNGAPI
png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn) png_set_read_status_fn(png_structp png_ptr, png_read_status_ptr read_row_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->read_row_fn = read_row_fn; png_ptr->read_row_fn = read_row_fn;
} }
@@ -1310,9 +1320,10 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
{ {
int row; int row;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) #if defined(PNG_READ_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel from opacity to transparency /* Invert the alpha channel from opacity to transparency
*/ */
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
png_set_invert_alpha(png_ptr); png_set_invert_alpha(png_ptr);
@@ -1328,10 +1339,10 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
/* -------------- image transformations start here ------------------- */ /* -------------- image transformations start here ------------------- */
#if defined(PNG_READ_16_TO_8_SUPPORTED) #if defined(PNG_READ_16_TO_8_SUPPORTED)
/* tell libpng to strip 16 bit/color files down to 8 bits per color /* Tell libpng to strip 16 bit/color files down to 8 bits per color.
*/ */
if (transforms & PNG_TRANSFORM_STRIP_16) if (transforms & PNG_TRANSFORM_STRIP_16)
png_set_strip_16(png_ptr); png_set_strip_16(png_ptr);
#endif #endif
#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) #if defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
@@ -1339,7 +1350,7 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
* the background (not recommended). * the background (not recommended).
*/ */
if (transforms & PNG_TRANSFORM_STRIP_ALPHA) if (transforms & PNG_TRANSFORM_STRIP_ALPHA)
png_set_strip_alpha(png_ptr); png_set_strip_alpha(png_ptr);
#endif #endif
#if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED) #if defined(PNG_READ_PACK_SUPPORTED) && !defined(PNG_READ_EXPAND_SUPPORTED)
@@ -1347,7 +1358,7 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
* byte into separate bytes (useful for paletted and grayscale images). * byte into separate bytes (useful for paletted and grayscale images).
*/ */
if (transforms & PNG_TRANSFORM_PACKING) if (transforms & PNG_TRANSFORM_PACKING)
png_set_packing(png_ptr); png_set_packing(png_ptr);
#endif #endif
#if defined(PNG_READ_PACKSWAP_SUPPORTED) #if defined(PNG_READ_PACKSWAP_SUPPORTED)
@@ -1355,7 +1366,7 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
* (not useful if you are using png_set_packing). * (not useful if you are using png_set_packing).
*/ */
if (transforms & PNG_TRANSFORM_PACKSWAP) if (transforms & PNG_TRANSFORM_PACKSWAP)
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
#endif #endif
#if defined(PNG_READ_EXPAND_SUPPORTED) #if defined(PNG_READ_EXPAND_SUPPORTED)
@@ -1365,9 +1376,9 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
* channels so the data will be available as RGBA quartets. * channels so the data will be available as RGBA quartets.
*/ */
if (transforms & PNG_TRANSFORM_EXPAND) if (transforms & PNG_TRANSFORM_EXPAND)
if ((png_ptr->bit_depth < 8) || if ((png_ptr->bit_depth < 8) ||
(png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) || (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ||
(png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))) (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)))
png_set_expand(png_ptr); png_set_expand(png_ptr);
#endif #endif
@@ -1375,10 +1386,10 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
*/ */
#if defined(PNG_READ_INVERT_SUPPORTED) #if defined(PNG_READ_INVERT_SUPPORTED)
/* invert monochrome files to have 0 as white and 1 as black /* Invert monochrome files to have 0 as white and 1 as black
*/ */
if (transforms & PNG_TRANSFORM_INVERT_MONO) if (transforms & PNG_TRANSFORM_INVERT_MONO)
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
#endif #endif
#if defined(PNG_READ_SHIFT_SUPPORTED) #if defined(PNG_READ_SHIFT_SUPPORTED)
@@ -1397,24 +1408,24 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
#endif #endif
#if defined(PNG_READ_BGR_SUPPORTED) #if defined(PNG_READ_BGR_SUPPORTED)
/* flip the RGB pixels to BGR (or RGBA to BGRA) /* Flip the RGB pixels to BGR (or RGBA to BGRA)
*/ */
if (transforms & PNG_TRANSFORM_BGR) if (transforms & PNG_TRANSFORM_BGR)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
#endif #endif
#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) #if defined(PNG_READ_SWAP_ALPHA_SUPPORTED)
/* swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR)
*/ */
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
#endif #endif
#if defined(PNG_READ_SWAP_SUPPORTED) #if defined(PNG_READ_SWAP_SUPPORTED)
/* swap bytes of 16 bit files to least significant byte first /* Swap bytes of 16 bit files to least significant byte first
*/ */
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
png_set_swap(png_ptr); png_set_swap(png_ptr);
#endif #endif
/* We don't handle adding filler bytes */ /* We don't handle adding filler bytes */
@@ -1434,11 +1445,11 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
{ {
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
info_ptr->height * png_sizeof(png_bytep)); info_ptr->height * png_sizeof(png_bytep));
png_memset(info_ptr->row_pointers, 0, info_ptr->height
* png_sizeof(png_bytep));
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_ROWS; info_ptr->free_me |= PNG_FREE_ROWS;
#endif #endif
png_memset(info_ptr->row_pointers, 0, info_ptr->height
* png_sizeof(png_bytep));
for (row = 0; row < (int)info_ptr->height; row++) for (row = 0; row < (int)info_ptr->height; row++)
info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr, info_ptr->row_pointers[row] = (png_bytep)png_malloc(png_ptr,
png_get_rowbytes(png_ptr, info_ptr)); png_get_rowbytes(png_ptr, info_ptr));
@@ -1447,10 +1458,10 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
png_read_image(png_ptr, info_ptr->row_pointers); png_read_image(png_ptr, info_ptr->row_pointers);
info_ptr->valid |= PNG_INFO_IDAT; info_ptr->valid |= PNG_INFO_IDAT;
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */ /* Read rest of file, and get additional chunks in info_ptr - REQUIRED */
png_read_end(png_ptr, info_ptr); png_read_end(png_ptr, info_ptr);
transforms = transforms; /* quiet compiler warnings */ transforms = transforms; /* Quiet compiler warnings */
params = params; params = params;
} }
src/libs/png/pngrio.c
+33 -25
View File
@@ -1,9 +1,9 @@
/* pngrio.c - functions for data input /* pngrio.c - functions for data input
* *
* Last changed in libpng 1.2.30 [August 15, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
@@ -20,10 +20,11 @@
#if defined(PNG_READ_SUPPORTED) #if defined(PNG_READ_SUPPORTED)
/* Read the data from whatever input you are using. The default routine /* Read the data from whatever input you are using. The default routine
reads from a file pointer. Note that this routine sometimes gets called * reads from a file pointer. Note that this routine sometimes gets called
with very small lengths, so you should implement some kind of simple * with very small lengths, so you should implement some kind of simple
buffering if you are using unbuffered reads. This should never be asked * buffering if you are using unbuffered reads. This should never be asked
to read more then 64K on a 16 bit machine. */ * to read more then 64K on a 16 bit machine.
*/
void /* PRIVATE */ void /* PRIVATE */
png_read_data(png_structp png_ptr, png_bytep data, png_size_t length) png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
@@ -36,16 +37,18 @@ png_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
/* This is the function that does the actual reading of data. If you are /* This is the function that does the actual reading of data. If you are
not reading from a standard C stream, you should create a replacement * not reading from a standard C stream, you should create a replacement
read_data function and use it at run time with png_set_read_fn(), rather * read_data function and use it at run time with png_set_read_fn(), rather
than changing the library. */ * than changing the library.
*/
#ifndef USE_FAR_KEYWORD #ifndef USE_FAR_KEYWORD
void PNGAPI void PNGAPI
png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length) png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
png_size_t check; png_size_t check;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
/* fread() returns 0 on error, so it is OK to store this in a png_size_t /* fread() returns 0 on error, so it is OK to store this in a png_size_t
* instead of an int, which is what fread() actually returns. * instead of an int, which is what fread() actually returns.
*/ */
@@ -61,7 +64,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_error(png_ptr, "Read Error"); png_error(png_ptr, "Read Error");
} }
#else #else
/* this is the model-independent version. Since the standard I/O library /* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy can't handle far buffers in the medium and small models, we have to copy
the data. the data.
*/ */
@@ -76,7 +79,8 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_byte *n_data; png_byte *n_data;
png_FILE_p io_ptr; png_FILE_p io_ptr;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
/* Check if data really is near. If so, use usual code. */ /* Check if data really is near. If so, use usual code. */
n_data = (png_byte *)CVT_PTR_NOCHECK(data); n_data = (png_byte *)CVT_PTR_NOCHECK(data);
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
@@ -121,23 +125,27 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
#endif #endif
/* This function allows the application to supply a new input function /* This function allows the application to supply a new input function
for libpng if standard C streams aren't being used. * for libpng if standard C streams aren't being used.
*
This function takes as its arguments: * This function takes as its arguments:
png_ptr - pointer to a png input data structure * png_ptr - pointer to a png input data structure
io_ptr - pointer to user supplied structure containing info about * io_ptr - pointer to user supplied structure containing info about
the input functions. May be NULL. * the input functions. May be NULL.
read_data_fn - pointer to a new input function that takes as its * read_data_fn - pointer to a new input function that takes as its
arguments a pointer to a png_struct, a pointer to * arguments a pointer to a png_struct, a pointer to
a location where input data can be stored, and a 32-bit * a location where input data can be stored, and a 32-bit
unsigned int that is the number of bytes to be read. * unsigned int that is the number of bytes to be read.
To exit and output any fatal error messages the new write * To exit and output any fatal error messages the new write
function should call png_error(png_ptr, "Error msg"). */ * function should call png_error(png_ptr, "Error msg").
* May be NULL, in which case libpng's default function will
* be used.
*/
void PNGAPI void PNGAPI
png_set_read_fn(png_structp png_ptr, png_voidp io_ptr, png_set_read_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr read_data_fn) png_rw_ptr read_data_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->io_ptr = io_ptr; png_ptr->io_ptr = io_ptr;
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
src/libs/png/pngrtran.c
+236 -155
View File
File diff suppressed because it is too large Load Diff
src/libs/png/pngrutil.c
+110 -87
View File
@@ -1,9 +1,9 @@
/* pngrutil.c - utilities to read a PNG file /* pngrutil.c - utilities to read a PNG file
* *
* Last changed in libpng 1.2.34 [December 18, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
* *
@@ -21,7 +21,7 @@
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
# if defined(WIN32_WCE_OLD) # if defined(WIN32_WCE_OLD)
/* strtod() function is not supported on WindowsCE */ /* The strtod() function is not supported on WindowsCE */
__inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, char **endptr) __inline double png_strtod(png_structp png_ptr, PNG_CONST char *nptr, char **endptr)
{ {
double result = 0; double result = 0;
@@ -76,7 +76,8 @@ png_get_uint_32(png_bytep buf)
/* Grab a signed 32-bit integer from a buffer in big-endian format. The /* Grab a signed 32-bit integer from a buffer in big-endian format. The
* data is stored in the PNG file in two's complement format, and it is * data is stored in the PNG file in two's complement format, and it is
* assumed that the machine format for signed integers is the same. */ * assumed that the machine format for signed integers is the same.
*/
png_int_32 PNGAPI png_int_32 PNGAPI
png_get_int_32(png_bytep buf) png_get_int_32(png_bytep buf)
{ {
@@ -108,21 +109,21 @@ png_read_chunk_header(png_structp png_ptr)
png_byte buf[8]; png_byte buf[8];
png_uint_32 length; png_uint_32 length;
/* read the length and the chunk name */ /* Read the length and the chunk name */
png_read_data(png_ptr, buf, 8); png_read_data(png_ptr, buf, 8);
length = png_get_uint_31(png_ptr, buf); length = png_get_uint_31(png_ptr, buf);
/* put the chunk name into png_ptr->chunk_name */ /* Put the chunk name into png_ptr->chunk_name */
png_memcpy(png_ptr->chunk_name, buf + 4, 4); png_memcpy(png_ptr->chunk_name, buf + 4, 4);
png_debug2(0, "Reading %s chunk, length = %lu", png_debug2(0, "Reading %s chunk, length = %lu",
png_ptr->chunk_name, length); png_ptr->chunk_name, length);
/* reset the crc and run it over the chunk name */ /* Reset the crc and run it over the chunk name */
png_reset_crc(png_ptr); png_reset_crc(png_ptr);
png_calculate_crc(png_ptr, png_ptr->chunk_name, 4); png_calculate_crc(png_ptr, png_ptr->chunk_name, 4);
/* check to see if chunk name is valid */ /* Check to see if chunk name is valid */
png_check_chunk_name(png_ptr, png_ptr->chunk_name); png_check_chunk_name(png_ptr, png_ptr->chunk_name);
return length; return length;
@@ -132,15 +133,17 @@ png_read_chunk_header(png_structp png_ptr)
void /* PRIVATE */ void /* PRIVATE */
png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length) png_crc_read(png_structp png_ptr, png_bytep buf, png_size_t length)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_read_data(png_ptr, buf, length); png_read_data(png_ptr, buf, length);
png_calculate_crc(png_ptr, buf, length); png_calculate_crc(png_ptr, buf, length);
} }
/* Optionally skip data and then check the CRC. Depending on whether we /* Optionally skip data and then check the CRC. Depending on whether we
are reading a ancillary or critical chunk, and how the program has set * are reading a ancillary or critical chunk, and how the program has set
things up, we may calculate the CRC on the data and print a message. * things up, we may calculate the CRC on the data and print a message.
Returns '1' if there was a CRC error, '0' otherwise. */ * Returns '1' if there was a CRC error, '0' otherwise.
*/
int /* PRIVATE */ int /* PRIVATE */
png_crc_finish(png_structp png_ptr, png_uint_32 skip) png_crc_finish(png_structp png_ptr, png_uint_32 skip)
{ {
@@ -159,7 +162,7 @@ png_crc_finish(png_structp png_ptr, png_uint_32 skip)
if (png_crc_error(png_ptr)) if (png_crc_error(png_ptr))
{ {
if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */ if (((png_ptr->chunk_name[0] & 0x20) && /* Ancillary */
!(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) || !(png_ptr->flags & PNG_FLAG_CRC_ANCILLARY_NOWARN)) ||
(!(png_ptr->chunk_name[0] & 0x20) && /* Critical */ (!(png_ptr->chunk_name[0] & 0x20) && /* Critical */
(png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE))) (png_ptr->flags & PNG_FLAG_CRC_CRITICAL_USE)))
{ {
@@ -176,7 +179,8 @@ png_crc_finish(png_structp png_ptr, png_uint_32 skip)
} }
/* Compare the CRC stored in the PNG file with that calculated by libpng from /* Compare the CRC stored in the PNG file with that calculated by libpng from
the data it has read thus far. */ * the data it has read thus far.
*/
int /* PRIVATE */ int /* PRIVATE */
png_crc_error(png_structp png_ptr) png_crc_error(png_structp png_ptr)
{ {
@@ -331,14 +335,17 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
png_snprintf(umsg, 52, png_snprintf(umsg, 52,
"Buffer error in compressed datastream in %s chunk", "Buffer error in compressed datastream in %s chunk",
png_ptr->chunk_name); png_ptr->chunk_name);
else if (ret == Z_DATA_ERROR) else if (ret == Z_DATA_ERROR)
png_snprintf(umsg, 52, png_snprintf(umsg, 52,
"Data error in compressed datastream in %s chunk", "Data error in compressed datastream in %s chunk",
png_ptr->chunk_name); png_ptr->chunk_name);
else else
png_snprintf(umsg, 52, png_snprintf(umsg, 52,
"Incomplete compressed datastream in %s chunk", "Incomplete compressed datastream in %s chunk",
png_ptr->chunk_name); png_ptr->chunk_name);
png_warning(png_ptr, umsg); png_warning(png_ptr, umsg);
#else #else
png_warning(png_ptr, png_warning(png_ptr,
@@ -383,7 +390,7 @@ png_decompress_chunk(png_structp png_ptr, int comp_type,
} }
#endif #endif
/* read and check the IDHR chunk */ /* Read and check the IDHR chunk */
void /* PRIVATE */ void /* PRIVATE */
png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@@ -397,7 +404,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
if (png_ptr->mode & PNG_HAVE_IHDR) if (png_ptr->mode & PNG_HAVE_IHDR)
png_error(png_ptr, "Out of place IHDR"); png_error(png_ptr, "Out of place IHDR");
/* check the length */ /* Check the length */
if (length != 13) if (length != 13)
png_error(png_ptr, "Invalid IHDR chunk"); png_error(png_ptr, "Invalid IHDR chunk");
@@ -414,7 +421,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
filter_type = buf[11]; filter_type = buf[11];
interlace_type = buf[12]; interlace_type = buf[12];
/* set internal variables */ /* Set internal variables */
png_ptr->width = width; png_ptr->width = width;
png_ptr->height = height; png_ptr->height = height;
png_ptr->bit_depth = (png_byte)bit_depth; png_ptr->bit_depth = (png_byte)bit_depth;
@@ -425,25 +432,28 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
png_ptr->compression_type = (png_byte)compression_type; png_ptr->compression_type = (png_byte)compression_type;
/* find number of channels */ /* Find number of channels */
switch (png_ptr->color_type) switch (png_ptr->color_type)
{ {
case PNG_COLOR_TYPE_GRAY: case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_PALETTE: case PNG_COLOR_TYPE_PALETTE:
png_ptr->channels = 1; png_ptr->channels = 1;
break; break;
case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_RGB:
png_ptr->channels = 3; png_ptr->channels = 3;
break; break;
case PNG_COLOR_TYPE_GRAY_ALPHA: case PNG_COLOR_TYPE_GRAY_ALPHA:
png_ptr->channels = 2; png_ptr->channels = 2;
break; break;
case PNG_COLOR_TYPE_RGB_ALPHA: case PNG_COLOR_TYPE_RGB_ALPHA:
png_ptr->channels = 4; png_ptr->channels = 4;
break; break;
} }
/* set up other useful info */ /* Set up other useful info */
png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth * png_ptr->pixel_depth = (png_byte)(png_ptr->bit_depth *
png_ptr->channels); png_ptr->channels);
png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width); png_ptr->rowbytes = PNG_ROWBYTES(png_ptr->pixel_depth, png_ptr->width);
@@ -454,7 +464,7 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
color_type, interlace_type, compression_type, filter_type); color_type, interlace_type, compression_type, filter_type);
} }
/* read and check the palette */ /* Read and check the palette */
void /* PRIVATE */ void /* PRIVATE */
png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@@ -468,12 +478,14 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before PLTE"); png_error(png_ptr, "Missing IHDR before PLTE");
else if (png_ptr->mode & PNG_HAVE_IDAT) else if (png_ptr->mode & PNG_HAVE_IDAT)
{ {
png_warning(png_ptr, "Invalid PLTE after IDAT"); png_warning(png_ptr, "Invalid PLTE after IDAT");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
return; return;
} }
else if (png_ptr->mode & PNG_HAVE_PLTE) else if (png_ptr->mode & PNG_HAVE_PLTE)
png_error(png_ptr, "Duplicate PLTE chunk"); png_error(png_ptr, "Duplicate PLTE chunk");
@@ -502,6 +514,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
return; return;
} }
else else
{ {
png_error(png_ptr, "Invalid palette chunk"); png_error(png_ptr, "Invalid palette chunk");
@@ -526,7 +539,7 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_byte buf[3]; png_byte buf[3];
png_crc_read(png_ptr, buf, 3); png_crc_read(png_ptr, buf, 3);
/* don't depend upon png_color being any order */ /* Don't depend upon png_color being any order */
palette[i].red = buf[0]; palette[i].red = buf[0];
palette[i].green = buf[1]; palette[i].green = buf[1];
palette[i].blue = buf[2]; palette[i].blue = buf[2];
@@ -534,9 +547,10 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
/* If we actually NEED the PLTE chunk (ie for a paletted image), we do /* If we actually NEED the PLTE chunk (ie for a paletted image), we do
whatever the normal CRC configuration tells us. However, if we * whatever the normal CRC configuration tells us. However, if we
have an RGB image, the PLTE can be considered ancillary, so * have an RGB image, the PLTE can be considered ancillary, so
we will act as though it is. */ * we will act as though it is.
*/
#if !defined(PNG_READ_OPT_PLTE_SUPPORTED) #if !defined(PNG_READ_OPT_PLTE_SUPPORTED)
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
#endif #endif
@@ -611,7 +625,7 @@ png_handle_IEND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */
} }
#if defined(PNG_READ_gAMA_SUPPORTED) #if defined(PNG_READ_gAMA_SUPPORTED)
@@ -661,7 +675,7 @@ png_handle_gAMA(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
igamma = (png_fixed_point)png_get_uint_32(buf); igamma = (png_fixed_point)png_get_uint_32(buf);
/* check for zero gamma */ /* Check for zero gamma */
if (igamma == 0) if (igamma == 0)
{ {
png_warning(png_ptr, png_warning(png_ptr,
@@ -925,7 +939,7 @@ png_handle_sRGB(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
intent = buf[0]; intent = buf[0];
/* check for bad intent */ /* Check for bad intent */
if (intent >= PNG_sRGB_INTENT_LAST) if (intent >= PNG_sRGB_INTENT_LAST)
{ {
png_warning(png_ptr, "Unknown sRGB intent"); png_warning(png_ptr, "Unknown sRGB intent");
@@ -1040,12 +1054,13 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (profile = png_ptr->chunkdata; *profile; profile++) for (profile = png_ptr->chunkdata; *profile; profile++)
/* empty loop to find end of name */ ; /* Empty loop to find end of name */ ;
++profile; ++profile;
/* there should be at least one zero (the compression type byte) /* There should be at least one zero (the compression type byte)
following the separator, and we should be on it */ * following the separator, and we should be on it
*/
if ( profile >= png_ptr->chunkdata + slength - 1) if ( profile >= png_ptr->chunkdata + slength - 1)
{ {
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
@@ -1054,7 +1069,7 @@ png_handle_iCCP(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
} }
/* compression_type should always be zero */ /* Compression_type should always be zero */
compression_type = *profile++; compression_type = *profile++;
if (compression_type) if (compression_type)
{ {
@@ -1152,10 +1167,10 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++) for (entry_start = (png_bytep)png_ptr->chunkdata; *entry_start; entry_start++)
/* empty loop to find end of name */ ; /* Empty loop to find end of name */ ;
++entry_start; ++entry_start;
/* a sample depth should follow the separator, and we should be on it */ /* A sample depth should follow the separator, and we should be on it */
if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2) if (entry_start > (png_bytep)png_ptr->chunkdata + slength - 2)
{ {
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
@@ -1168,7 +1183,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
entry_size = (new_palette.depth == 8 ? 6 : 10); entry_size = (new_palette.depth == 8 ? 6 : 10);
data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata)); data_length = (slength - (entry_start - (png_bytep)png_ptr->chunkdata));
/* integrity-check the data length */ /* Integrity-check the data length */
if (data_length % entry_size) if (data_length % entry_size)
{ {
png_free(png_ptr, png_ptr->chunkdata); png_free(png_ptr, png_ptr->chunkdata);
@@ -1236,7 +1251,7 @@ png_handle_sPLT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
#endif #endif
/* discard all chunk data except the name and stash that */ /* Discard all chunk data except the name and stash that */
new_palette.name = png_ptr->chunkdata; new_palette.name = png_ptr->chunkdata;
png_set_sPLT(png_ptr, info_ptr, &new_palette, 1); png_set_sPLT(png_ptr, info_ptr, &new_palette, 1);
@@ -1572,7 +1587,7 @@ png_handle_oFFs(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_pCAL_SUPPORTED) #if defined(PNG_READ_pCAL_SUPPORTED)
/* read the pCAL chunk (described in the PNG Extensions document) */ /* Read the pCAL chunk (described in the PNG Extensions document) */
void /* PRIVATE */ void /* PRIVATE */
png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@@ -1619,11 +1634,11 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
} }
png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */ png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
png_debug(3, "Finding end of pCAL purpose string"); png_debug(3, "Finding end of pCAL purpose string");
for (buf = png_ptr->chunkdata; *buf; buf++) for (buf = png_ptr->chunkdata; *buf; buf++)
/* empty loop */ ; /* Empty loop */ ;
endptr = png_ptr->chunkdata + slength; endptr = png_ptr->chunkdata + slength;
@@ -1706,7 +1721,7 @@ png_handle_pCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_sCAL_SUPPORTED) #if defined(PNG_READ_sCAL_SUPPORTED)
/* read the sCAL chunk */ /* Read the sCAL chunk */
void /* PRIVATE */ void /* PRIVATE */
png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@@ -1756,9 +1771,9 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
return; return;
} }
png_ptr->chunkdata[slength] = 0x00; /* null terminate the last string */ png_ptr->chunkdata[slength] = 0x00; /* Null terminate the last string */
ep = png_ptr->chunkdata + 1; /* skip unit byte */ ep = png_ptr->chunkdata + 1; /* Skip unit byte */
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
width = png_strtod(png_ptr, ep, &vp); width = png_strtod(png_ptr, ep, &vp);
@@ -1780,7 +1795,7 @@ png_handle_sCAL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
for (ep = png_ptr->chunkdata; *ep; ep++) for (ep = png_ptr->chunkdata; *ep; ep++)
/* empty loop */ ; /* Empty loop */ ;
ep++; ep++;
if (png_ptr->chunkdata + slength < ep) if (png_ptr->chunkdata + slength < ep)
@@ -1944,7 +1959,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
key[slength] = 0x00; key[slength] = 0x00;
for (text = key; *text; text++) for (text = key; *text; text++)
/* empty loop to find end of key */ ; /* Empty loop to find end of key */ ;
if (text != key + slength) if (text != key + slength)
text++; text++;
@@ -1979,7 +1994,7 @@ png_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_zTXt_SUPPORTED) #if defined(PNG_READ_zTXt_SUPPORTED)
/* note: this does not correctly handle chunks that are > 64K under DOS */ /* Note: this does not correctly handle chunks that are > 64K under DOS */
void /* PRIVATE */ void /* PRIVATE */
png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@@ -2028,7 +2043,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (text = png_ptr->chunkdata; *text; text++) for (text = png_ptr->chunkdata; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
/* zTXt must have some text after the chunkdataword */ /* zTXt must have some text after the chunkdataword */
if (text >= png_ptr->chunkdata + slength - 2) if (text >= png_ptr->chunkdata + slength - 2)
@@ -2046,7 +2061,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_warning(png_ptr, "Unknown compression type in zTXt chunk"); png_warning(png_ptr, "Unknown compression type in zTXt chunk");
comp_type = PNG_TEXT_COMPRESSION_zTXt; comp_type = PNG_TEXT_COMPRESSION_zTXt;
} }
text++; /* skip the compression_method byte */ text++; /* Skip the compression_method byte */
} }
prefix_len = text - png_ptr->chunkdata; prefix_len = text - png_ptr->chunkdata;
@@ -2083,7 +2098,7 @@ png_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#endif #endif
#if defined(PNG_READ_iTXt_SUPPORTED) #if defined(PNG_READ_iTXt_SUPPORTED)
/* note: this does not correctly handle chunks that are > 64K under DOS */ /* Note: this does not correctly handle chunks that are > 64K under DOS */
void /* PRIVATE */ void /* PRIVATE */
png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
{ {
@@ -2133,12 +2148,13 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_ptr->chunkdata[slength] = 0x00; png_ptr->chunkdata[slength] = 0x00;
for (lang = png_ptr->chunkdata; *lang; lang++) for (lang = png_ptr->chunkdata; *lang; lang++)
/* empty loop */ ; /* Empty loop */ ;
lang++; /* skip NUL separator */ lang++; /* Skip NUL separator */
/* iTXt must have a language tag (possibly empty), two compression bytes, /* iTXt must have a language tag (possibly empty), two compression bytes,
translated keyword (possibly empty), and possibly some text after the * translated keyword (possibly empty), and possibly some text after the
keyword */ * keyword
*/
if (lang >= png_ptr->chunkdata + slength - 3) if (lang >= png_ptr->chunkdata + slength - 3)
{ {
@@ -2154,8 +2170,8 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
for (lang_key = lang; *lang_key; lang_key++) for (lang_key = lang; *lang_key; lang_key++)
/* empty loop */ ; /* Empty loop */ ;
lang_key++; /* skip NUL separator */ lang_key++; /* Skip NUL separator */
if (lang_key >= png_ptr->chunkdata + slength) if (lang_key >= png_ptr->chunkdata + slength)
{ {
@@ -2166,8 +2182,8 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
} }
for (text = lang_key; *text; text++) for (text = lang_key; *text; text++)
/* empty loop */ ; /* Empty loop */ ;
text++; /* skip NUL separator */ text++; /* Skip NUL separator */
if (text >= png_ptr->chunkdata + slength) if (text >= png_ptr->chunkdata + slength)
{ {
png_warning(png_ptr, "Malformed iTXt chunk"); png_warning(png_ptr, "Malformed iTXt chunk");
@@ -2229,7 +2245,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
PNG_CONST PNG_IDAT; PNG_CONST PNG_IDAT;
#endif #endif
if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* not an IDAT */ if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) /* Not an IDAT */
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
} }
@@ -2273,7 +2289,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
#if defined(PNG_READ_USER_CHUNKS_SUPPORTED) #if defined(PNG_READ_USER_CHUNKS_SUPPORTED)
if (png_ptr->read_user_chunk_fn != NULL) if (png_ptr->read_user_chunk_fn != NULL)
{ {
/* callback to user unknown chunk handler */ /* Callback to user unknown chunk handler */
int ret; int ret;
ret = (*(png_ptr->read_user_chunk_fn)) ret = (*(png_ptr->read_user_chunk_fn))
(png_ptr, &png_ptr->unknown_chunk); (png_ptr, &png_ptr->unknown_chunk);
@@ -2302,7 +2318,7 @@ png_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
png_crc_finish(png_ptr, skip); png_crc_finish(png_ptr, skip);
#if !defined(PNG_READ_USER_CHUNKS_SUPPORTED) #if !defined(PNG_READ_USER_CHUNKS_SUPPORTED)
info_ptr = info_ptr; /* quiet compiler warnings about unused info_ptr */ info_ptr = info_ptr; /* Quiet compiler warnings about unused info_ptr */
#endif #endif
} }
@@ -2550,8 +2566,8 @@ png_do_read_interlace(png_structp png_ptr)
int pass = png_ptr->pass; int pass = png_ptr->pass;
png_uint_32 transformations = png_ptr->transformations; png_uint_32 transformations = png_ptr->transformations;
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
#endif #endif
@@ -2759,7 +2775,7 @@ png_do_read_interlace(png_structp png_ptr)
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width); row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, final_width);
} }
#if !defined(PNG_READ_PACKSWAP_SUPPORTED) #if !defined(PNG_READ_PACKSWAP_SUPPORTED)
transformations = transformations; /* silence compiler warning */ transformations = transformations; /* Silence compiler warning */
#endif #endif
} }
#endif /* PNG_READ_INTERLACING_SUPPORTED */ #endif /* PNG_READ_INTERLACING_SUPPORTED */
@@ -2843,7 +2859,7 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
rp++; rp++;
} }
for (i = 0; i < istop; i++) /* use leftover rp,pp */ for (i = 0; i < istop; i++) /* Use leftover rp,pp */
{ {
int a, b, c, pa, pb, pc, p; int a, b, c, pa, pb, pc, p;
@@ -2887,23 +2903,24 @@ png_read_filter_row(png_structp png_ptr, png_row_infop row_info, png_bytep row,
} }
} }
#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_read_finish_row(png_structp png_ptr) png_read_finish_row(png_structp png_ptr)
{ {
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
/* offset to next interlace block in the y direction */ /* Offset to next interlace block in the y direction */
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif /* PNG_READ_INTERLACING_SUPPORTED */ #endif /* PNG_READ_INTERLACING_SUPPORTED */
#endif #endif
@@ -3018,24 +3035,25 @@ png_read_finish_row(png_structp png_ptr)
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
} }
#endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */
void /* PRIVATE */ void /* PRIVATE */
png_read_start_row(png_structp png_ptr) png_read_start_row(png_structp png_ptr)
{ {
#ifdef PNG_USE_LOCAL_ARRAYS #ifdef PNG_USE_LOCAL_ARRAYS
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
/* start of interlace block */ /* Start of interlace block */
PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0}; PNG_CONST int png_pass_start[7] = {0, 4, 0, 2, 0, 1, 0};
/* offset to next interlace block */ /* Offset to next interlace block */
PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1}; PNG_CONST int png_pass_inc[7] = {8, 8, 4, 4, 2, 2, 1};
/* start of interlace block in the y direction */ /* Start of interlace block in the y direction */
PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1}; PNG_CONST int png_pass_ystart[7] = {0, 0, 4, 0, 2, 0, 1};
/* offset to next interlace block in the y direction */ /* Offset to next interlace block in the y direction */
PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; PNG_CONST int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif #endif
#endif #endif
@@ -3172,11 +3190,13 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
} }
#endif #endif
/* align the width on the next larger 8 pixels. Mainly used /* Align the width on the next larger 8 pixels. Mainly used
for interlacing */ * for interlacing
*/
row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7)); row_bytes = ((png_ptr->width + 7) & ~((png_uint_32)7));
/* calculate the maximum bytes needed, adding a byte and a pixel /* Calculate the maximum bytes needed, adding a byte and a pixel
for safety's sake */ * for safety's sake
*/
row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) + row_bytes = PNG_ROWBYTES(max_pixel_depth, row_bytes) +
1 + ((max_pixel_depth + 7) >> 3); 1 + ((max_pixel_depth + 7) >> 3);
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
@@ -3187,27 +3207,30 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
if (row_bytes + 64 > png_ptr->old_big_row_buf_size) if (row_bytes + 64 > png_ptr->old_big_row_buf_size)
{ {
png_free(png_ptr, png_ptr->big_row_buf); png_free(png_ptr, png_ptr->big_row_buf);
png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 64);
png_ptr->row_buf = png_ptr->big_row_buf+32; if (png_ptr->interlaced)
png_ptr->old_big_row_buf_size = row_bytes+64; png_memset(png_ptr->big_row_buf, 0, row_bytes + 64);
png_ptr->row_buf = png_ptr->big_row_buf + 32;
png_ptr->old_big_row_buf_size = row_bytes + 64;
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
if ((png_uint_32)png_ptr->rowbytes + 1 > (png_uint_32)65536L) if ((png_uint_32)row_bytes + 1 > (png_uint_32)65536L)
png_error(png_ptr, "This image requires a row greater than 64KB"); png_error(png_ptr, "This image requires a row greater than 64KB");
#endif #endif
if ((png_uint_32)png_ptr->rowbytes > (png_uint_32)(PNG_SIZE_MAX - 1)) if ((png_uint_32)row_bytes > (png_uint_32)(PNG_SIZE_MAX - 1))
png_error(png_ptr, "Row has too many bytes to allocate in memory."); png_error(png_ptr, "Row has too many bytes to allocate in memory.");
if (png_ptr->rowbytes+1 > png_ptr->old_prev_row_size) if (row_bytes + 1 > png_ptr->old_prev_row_size)
{ {
png_free(png_ptr, png_ptr->prev_row); png_free(png_ptr, png_ptr->prev_row);
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)( png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)(
png_ptr->rowbytes + 1)); row_bytes + 1));
png_ptr->old_prev_row_size = png_ptr->rowbytes+1; png_memset_check(png_ptr, png_ptr->prev_row, 0, row_bytes + 1);
png_ptr->old_prev_row_size = row_bytes + 1;
} }
png_memset_check(png_ptr, png_ptr->prev_row, 0, png_ptr->rowbytes + 1); png_ptr->rowbytes = row_bytes;
png_debug1(3, "width = %lu,", png_ptr->width); png_debug1(3, "width = %lu,", png_ptr->width);
png_debug1(3, "height = %lu,", png_ptr->height); png_debug1(3, "height = %lu,", png_ptr->height);
src/libs/png/pngset.c
+239 -239
View File
@@ -1,7 +1,7 @@
/* pngset.c - storage of image information into info struct /* pngset.c - storage of image information into info struct
* *
* Last changed in libpng 1.2.35 [February 14, 2009] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -79,25 +79,25 @@ png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y)) white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y))
#endif #endif
{ {
info_ptr->int_x_white = white_x; info_ptr->int_x_white = white_x;
info_ptr->int_y_white = white_y; info_ptr->int_y_white = white_y;
info_ptr->int_x_red = red_x; info_ptr->int_x_red = red_x;
info_ptr->int_y_red = red_y; info_ptr->int_y_red = red_y;
info_ptr->int_x_green = green_x; info_ptr->int_x_green = green_x;
info_ptr->int_y_green = green_y; info_ptr->int_y_green = green_y;
info_ptr->int_x_blue = blue_x; info_ptr->int_x_blue = blue_x;
info_ptr->int_y_blue = blue_y; info_ptr->int_y_blue = blue_y;
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
info_ptr->x_white = (float)(white_x/100000.); info_ptr->x_white = (float)(white_x/100000.);
info_ptr->y_white = (float)(white_y/100000.); info_ptr->y_white = (float)(white_y/100000.);
info_ptr->x_red = (float)( red_x/100000.); info_ptr->x_red = (float)( red_x/100000.);
info_ptr->y_red = (float)( red_y/100000.); info_ptr->y_red = (float)( red_y/100000.);
info_ptr->x_green = (float)(green_x/100000.); info_ptr->x_green = (float)(green_x/100000.);
info_ptr->y_green = (float)(green_y/100000.); info_ptr->y_green = (float)(green_y/100000.);
info_ptr->x_blue = (float)( blue_x/100000.); info_ptr->x_blue = (float)( blue_x/100000.);
info_ptr->y_blue = (float)( blue_y/100000.); info_ptr->y_blue = (float)( blue_y/100000.);
#endif #endif
info_ptr->valid |= PNG_INFO_cHRM; info_ptr->valid |= PNG_INFO_cHRM;
} }
} }
#endif /* PNG_FIXED_POINT_SUPPORTED */ #endif /* PNG_FIXED_POINT_SUPPORTED */
@@ -108,7 +108,7 @@ png_set_cHRM_fixed(png_structp png_ptr, png_infop info_ptr,
void PNGAPI void PNGAPI
png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma) png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
{ {
double gamma; double png_gamma;
png_debug1(1, "in %s storage function", "gAMA"); png_debug1(1, "in %s storage function", "gAMA");
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
@@ -117,16 +117,16 @@ png_set_gAMA(png_structp png_ptr, png_infop info_ptr, double file_gamma)
if (file_gamma > 21474.83) if (file_gamma > 21474.83)
{ {
png_warning(png_ptr, "Limiting gamma to 21474.83"); png_warning(png_ptr, "Limiting gamma to 21474.83");
gamma=21474.83; png_gamma=21474.83;
} }
else else
gamma = file_gamma; png_gamma = file_gamma;
info_ptr->gamma = (float)gamma; info_ptr->gamma = (float)png_gamma;
#ifdef PNG_FIXED_POINT_SUPPORTED #ifdef PNG_FIXED_POINT_SUPPORTED
info_ptr->int_gamma = (int)(gamma*100000.+.5); info_ptr->int_gamma = (int)(png_gamma*100000.+.5);
#endif #endif
info_ptr->valid |= PNG_INFO_gAMA; info_ptr->valid |= PNG_INFO_gAMA;
if (gamma == 0.0) if (png_gamma == 0.0)
png_warning(png_ptr, "Setting gamma=0"); png_warning(png_ptr, "Setting gamma=0");
} }
#endif #endif
@@ -134,35 +134,35 @@ void PNGAPI
png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point png_set_gAMA_fixed(png_structp png_ptr, png_infop info_ptr, png_fixed_point
int_gamma) int_gamma)
{ {
png_fixed_point gamma; png_fixed_point png_gamma;
png_debug1(1, "in %s storage function", "gAMA"); png_debug1(1, "in %s storage function", "gAMA");
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
if (int_gamma > (png_fixed_point) PNG_UINT_31_MAX) if (int_gamma > (png_fixed_point)PNG_UINT_31_MAX)
{ {
png_warning(png_ptr, "Limiting gamma to 21474.83"); png_warning(png_ptr, "Limiting gamma to 21474.83");
gamma=PNG_UINT_31_MAX; png_gamma=PNG_UINT_31_MAX;
} }
else else
{ {
if (int_gamma < 0) if (int_gamma < 0)
{ {
png_warning(png_ptr, "Setting negative gamma to zero"); png_warning(png_ptr, "Setting negative gamma to zero");
gamma = 0; png_gamma = 0;
} }
else else
gamma = int_gamma; png_gamma = int_gamma;
} }
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
info_ptr->gamma = (float)(gamma/100000.); info_ptr->gamma = (float)(png_gamma/100000.);
#endif #endif
#ifdef PNG_FIXED_POINT_SUPPORTED #ifdef PNG_FIXED_POINT_SUPPORTED
info_ptr->int_gamma = gamma; info_ptr->int_gamma = png_gamma;
#endif #endif
info_ptr->valid |= PNG_INFO_gAMA; info_ptr->valid |= PNG_INFO_gAMA;
if (gamma == 0) if (png_gamma == 0)
png_warning(png_ptr, "Setting gamma=0"); png_warning(png_ptr, "Setting gamma=0");
} }
#endif #endif
@@ -179,26 +179,27 @@ png_set_hIST(png_structp png_ptr, png_infop info_ptr, png_uint_16p hist)
if (info_ptr->num_palette == 0 || info_ptr->num_palette if (info_ptr->num_palette == 0 || info_ptr->num_palette
> PNG_MAX_PALETTE_LENGTH) > PNG_MAX_PALETTE_LENGTH)
{ {
png_warning(png_ptr, png_warning(png_ptr,
"Invalid palette size, hIST allocation skipped."); "Invalid palette size, hIST allocation skipped.");
return; return;
} }
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0); png_free_data(png_ptr, info_ptr, PNG_FREE_HIST, 0);
#endif #endif
/* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in version /* Changed from info->num_palette to PNG_MAX_PALETTE_LENGTH in
1.2.1 */ * version 1.2.1
*/
png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr, png_ptr->hist = (png_uint_16p)png_malloc_warn(png_ptr,
(png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16))); (png_uint_32)(PNG_MAX_PALETTE_LENGTH * png_sizeof(png_uint_16)));
if (png_ptr->hist == NULL) if (png_ptr->hist == NULL)
{ {
png_warning(png_ptr, "Insufficient memory for hIST chunk data."); png_warning(png_ptr, "Insufficient memory for hIST chunk data.");
return; return;
} }
for (i = 0; i < info_ptr->num_palette; i++) for (i = 0; i < info_ptr->num_palette; i++)
png_ptr->hist[i] = hist[i]; png_ptr->hist[i] = hist[i];
info_ptr->hist = png_ptr->hist; info_ptr->hist = png_ptr->hist;
info_ptr->valid |= PNG_INFO_hIST; info_ptr->valid |= PNG_INFO_hIST;
@@ -220,7 +221,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
/* check for width and height valid values */ /* Check for width and height valid values */
if (width == 0 || height == 0) if (width == 0 || height == 0)
png_error(png_ptr, "Image width or height is zero in IHDR"); png_error(png_ptr, "Image width or height is zero in IHDR");
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
@@ -240,13 +241,13 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
- 8) /* extra max_pixel_depth pad */ - 8) /* extra max_pixel_depth pad */
png_warning(png_ptr, "Width is too large for libpng to process pixels"); png_warning(png_ptr, "Width is too large for libpng to process pixels");
/* check other values */ /* Check other values */
if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 && if (bit_depth != 1 && bit_depth != 2 && bit_depth != 4 &&
bit_depth != 8 && bit_depth != 16) bit_depth != 8 && bit_depth != 16)
png_error(png_ptr, "Invalid bit depth in IHDR"); png_error(png_ptr, "Invalid bit depth in IHDR");
if (color_type < 0 || color_type == 1 || if (color_type < 0 || color_type == 1 ||
color_type == 5 || color_type > 6) color_type == 5 || color_type > 6)
png_error(png_ptr, "Invalid color type in IHDR"); png_error(png_ptr, "Invalid color type in IHDR");
if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) || if (((color_type == PNG_COLOR_TYPE_PALETTE) && bit_depth > 8) ||
@@ -276,9 +277,9 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
if (filter_type != PNG_FILTER_TYPE_BASE) if (filter_type != PNG_FILTER_TYPE_BASE)
{ {
if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && if (!((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
(filter_type == PNG_INTRAPIXEL_DIFFERENCING) && (filter_type == PNG_INTRAPIXEL_DIFFERENCING) &&
((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) && ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) == 0) &&
(color_type == PNG_COLOR_TYPE_RGB || (color_type == PNG_COLOR_TYPE_RGB ||
color_type == PNG_COLOR_TYPE_RGB_ALPHA))) color_type == PNG_COLOR_TYPE_RGB_ALPHA)))
png_error(png_ptr, "Unknown filter method in IHDR"); png_error(png_ptr, "Unknown filter method in IHDR");
if (png_ptr->mode&PNG_HAVE_PNG_SIGNATURE) if (png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)
@@ -306,7 +307,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
info_ptr->channels++; info_ptr->channels++;
info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth); info_ptr->pixel_depth = (png_byte)(info_ptr->channels * info_ptr->bit_depth);
/* check for potential overflow */ /* Check for potential overflow */
if (width > (PNG_UINT_32_MAX if (width > (PNG_UINT_32_MAX
>> 3) /* 8-byte RGBA pixels */ >> 3) /* 8-byte RGBA pixels */
- 64 /* bigrowbuf hack */ - 64 /* bigrowbuf hack */
@@ -383,10 +384,6 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
return; return;
} }
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_PCAL;
#endif
png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp)); png_memset(info_ptr->pcal_params, 0, (nparams + 1) * png_sizeof(png_charp));
for (i = 0; i < nparams; i++) for (i = 0; i < nparams; i++)
@@ -404,6 +401,9 @@ png_set_pCAL(png_structp png_ptr, png_infop info_ptr,
} }
info_ptr->valid |= PNG_INFO_pCAL; info_ptr->valid |= PNG_INFO_pCAL;
#ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_PCAL;
#endif
} }
#endif #endif
@@ -497,15 +497,15 @@ png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
return; return;
if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH) if (num_palette < 0 || num_palette > PNG_MAX_PALETTE_LENGTH)
{ {
if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
png_error(png_ptr, "Invalid palette length"); png_error(png_ptr, "Invalid palette length");
else else
{ {
png_warning(png_ptr, "Invalid palette length"); png_warning(png_ptr, "Invalid palette length");
return; return;
} }
} }
/* /*
* It may not actually be necessary to set png_ptr->palette here; * It may not actually be necessary to set png_ptr->palette here;
@@ -517,8 +517,9 @@ png_set_PLTE(png_structp png_ptr, png_infop info_ptr,
#endif #endif
/* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead /* Changed in libpng-1.2.1 to allocate PNG_MAX_PALETTE_LENGTH instead
of num_palette entries, * of num_palette entries, in case of an invalid PNG file that has
in case of an invalid PNG file that has too-large sample values. */ * too-large sample values.
*/
png_ptr->palette = (png_colorp)png_malloc(png_ptr, png_ptr->palette = (png_colorp)png_malloc(png_ptr,
PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color)); PNG_MAX_PALETTE_LENGTH * png_sizeof(png_color));
png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH * png_memset(png_ptr->palette, 0, PNG_MAX_PALETTE_LENGTH *
@@ -621,18 +622,18 @@ png_set_sRGB_gAMA_and_cHRM(png_structp png_ptr, png_infop info_ptr,
#if !defined(PNG_NO_CHECK_cHRM) #if !defined(PNG_NO_CHECK_cHRM)
if (png_check_cHRM_fixed(png_ptr, if (png_check_cHRM_fixed(png_ptr,
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
int_green_y, int_blue_x, int_blue_y)) int_green_y, int_blue_x, int_blue_y))
#endif #endif
{ {
#ifdef PNG_FIXED_POINT_SUPPORTED #ifdef PNG_FIXED_POINT_SUPPORTED
png_set_cHRM_fixed(png_ptr, info_ptr, png_set_cHRM_fixed(png_ptr, info_ptr,
int_white_x, int_white_y, int_red_x, int_red_y, int_green_x, int_white_x, int_white_y, int_red_x, int_red_y, int_green_x,
int_green_y, int_blue_x, int_blue_y); int_green_y, int_blue_x, int_blue_y);
#endif #endif
#ifdef PNG_FLOATING_POINT_SUPPORTED #ifdef PNG_FLOATING_POINT_SUPPORTED
png_set_cHRM(png_ptr, info_ptr, png_set_cHRM(png_ptr, info_ptr,
white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y); white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y);
#endif #endif
} }
#endif /* cHRM */ #endif /* cHRM */
@@ -690,17 +691,17 @@ png_set_iCCP(png_structp png_ptr, png_infop info_ptr,
#if defined(PNG_TEXT_SUPPORTED) #if defined(PNG_TEXT_SUPPORTED)
void PNGAPI void PNGAPI
png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, png_set_text(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
int num_text) int num_text)
{ {
int ret; int ret;
ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text); ret = png_set_text_2(png_ptr, info_ptr, text_ptr, num_text);
if (ret) if (ret)
png_error(png_ptr, "Insufficient memory to store text"); png_error(png_ptr, "Insufficient memory to store text");
} }
int /* PRIVATE */ int /* PRIVATE */
png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr, png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
int num_text) int num_text)
{ {
int i; int i;
@@ -726,10 +727,10 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
(png_uint_32)(info_ptr->max_text * png_sizeof(png_text))); (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
if (info_ptr->text == NULL) if (info_ptr->text == NULL)
{ {
png_free(png_ptr, old_text); png_free(png_ptr, old_text);
return(1); return(1);
} }
png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max * png_memcpy(info_ptr->text, old_text, (png_size_t)(old_max *
png_sizeof(png_text))); png_sizeof(png_text)));
png_free(png_ptr, old_text); png_free(png_ptr, old_text);
@@ -741,7 +742,7 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
info_ptr->text = (png_textp)png_malloc_warn(png_ptr, info_ptr->text = (png_textp)png_malloc_warn(png_ptr,
(png_uint_32)(info_ptr->max_text * png_sizeof(png_text))); (png_uint_32)(info_ptr->max_text * png_sizeof(png_text)));
if (info_ptr->text == NULL) if (info_ptr->text == NULL)
return(1); return(1);
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_TEXT; info_ptr->free_me |= PNG_FREE_TEXT;
#endif #endif
@@ -762,26 +763,26 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
if (text_ptr[i].compression <= 0) if (text_ptr[i].compression <= 0)
{ {
lang_len = 0; lang_len = 0;
lang_key_len = 0; lang_key_len = 0;
} }
else else
#ifdef PNG_iTXt_SUPPORTED #ifdef PNG_iTXt_SUPPORTED
{ {
/* set iTXt data */ /* Set iTXt data */
if (text_ptr[i].lang != NULL) if (text_ptr[i].lang != NULL)
lang_len = png_strlen(text_ptr[i].lang); lang_len = png_strlen(text_ptr[i].lang);
else else
lang_len = 0; lang_len = 0;
if (text_ptr[i].lang_key != NULL) if (text_ptr[i].lang_key != NULL)
lang_key_len = png_strlen(text_ptr[i].lang_key); lang_key_len = png_strlen(text_ptr[i].lang_key);
else else
lang_key_len = 0; lang_key_len = 0;
} }
#else #else
{ {
png_warning(png_ptr, "iTXt chunk not supported."); png_warning(png_ptr, "iTXt chunk not supported.");
continue; continue;
} }
#endif #endif
@@ -805,14 +806,13 @@ png_set_text_2(png_structp png_ptr, png_infop info_ptr, png_textp text_ptr,
(png_uint_32) (png_uint_32)
(key_len + text_length + lang_len + lang_key_len + 4)); (key_len + text_length + lang_len + lang_key_len + 4));
if (textp->key == NULL) if (textp->key == NULL)
return(1); return(1);
png_debug2(2, "Allocated %lu bytes at %x in png_set_text", png_debug2(2, "Allocated %lu bytes at %x in png_set_text",
(png_uint_32) (png_uint_32)
(key_len + lang_len + lang_key_len + text_length + 4), (key_len + lang_len + lang_key_len + text_length + 4),
(int)textp->key); (int)textp->key);
png_memcpy(textp->key, text_ptr[i].key, png_memcpy(textp->key, text_ptr[i].key,(png_size_t)(key_len));
(png_size_t)(key_len));
*(textp->key + key_len) = '\0'; *(textp->key + key_len) = '\0';
#ifdef PNG_iTXt_SUPPORTED #ifdef PNG_iTXt_SUPPORTED
if (text_ptr[i].compression > 0) if (text_ptr[i].compression > 0)
@@ -899,7 +899,7 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr, png_ptr->trans = info_ptr->trans = (png_bytep)png_malloc(png_ptr,
(png_uint_32)PNG_MAX_PALETTE_LENGTH); (png_uint_32)PNG_MAX_PALETTE_LENGTH);
if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH) if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans); png_memcpy(info_ptr->trans, trans, (png_size_t)num_trans);
} }
if (trans_values != NULL) if (trans_values != NULL)
@@ -911,12 +911,12 @@ png_set_tRNS(png_structp png_ptr, png_infop info_ptr,
((int)trans_values->red > sample_max || ((int)trans_values->red > sample_max ||
(int)trans_values->green > sample_max || (int)trans_values->green > sample_max ||
(int)trans_values->blue > sample_max))) (int)trans_values->blue > sample_max)))
png_warning(png_ptr, png_warning(png_ptr,
"tRNS chunk has out-of-range samples for bit_depth"); "tRNS chunk has out-of-range samples for bit_depth");
png_memcpy(&(info_ptr->trans_values), trans_values, png_memcpy(&(info_ptr->trans_values), trans_values,
png_sizeof(png_color_16)); png_sizeof(png_color_16));
if (num_trans == 0) if (num_trans == 0)
num_trans = 1; num_trans = 1;
} }
info_ptr->num_trans = (png_uint_16)num_trans; info_ptr->num_trans = (png_uint_16)num_trans;
@@ -944,63 +944,62 @@ png_set_sPLT(png_structp png_ptr,
* added. * added.
*/ */
{ {
png_sPLT_tp np; png_sPLT_tp np;
int i; int i;
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return;
np = (png_sPLT_tp)png_malloc_warn(png_ptr,
(info_ptr->splt_palettes_num + nentries) *
(png_uint_32)png_sizeof(png_sPLT_t));
if (np == NULL)
{
png_warning(png_ptr, "No memory for sPLT palettes.");
return; return;
}
png_memcpy(np, info_ptr->splt_palettes, np = (png_sPLT_tp)png_malloc_warn(png_ptr,
info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t)); (info_ptr->splt_palettes_num + nentries) *
(png_uint_32)png_sizeof(png_sPLT_t));
if (np == NULL)
{
png_warning(png_ptr, "No memory for sPLT palettes.");
return;
}
png_free(png_ptr, info_ptr->splt_palettes); png_memcpy(np, info_ptr->splt_palettes,
info_ptr->splt_palettes=NULL; info_ptr->splt_palettes_num * png_sizeof(png_sPLT_t));
png_free(png_ptr, info_ptr->splt_palettes);
info_ptr->splt_palettes=NULL;
for (i = 0; i < nentries; i++) for (i = 0; i < nentries; i++)
{ {
png_sPLT_tp to = np + info_ptr->splt_palettes_num + i; png_sPLT_tp to = np + info_ptr->splt_palettes_num + i;
png_sPLT_tp from = entries + i; png_sPLT_tp from = entries + i;
png_uint_32 length; png_uint_32 length;
length = png_strlen(from->name) + 1; length = png_strlen(from->name) + 1;
to->name = (png_charp)png_malloc_warn(png_ptr, length); to->name = (png_charp)png_malloc_warn(png_ptr, length);
if (to->name == NULL) if (to->name == NULL)
{ {
png_warning(png_ptr, png_warning(png_ptr,
"Out of memory while processing sPLT chunk"); "Out of memory while processing sPLT chunk");
continue; continue;
} }
png_memcpy(to->name, from->name, length); png_memcpy(to->name, from->name, length);
to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr, to->entries = (png_sPLT_entryp)png_malloc_warn(png_ptr,
(png_uint_32)(from->nentries * png_sizeof(png_sPLT_entry))); (png_uint_32)(from->nentries * png_sizeof(png_sPLT_entry)));
if (to->entries == NULL) if (to->entries == NULL)
{ {
png_warning(png_ptr, png_warning(png_ptr,
"Out of memory while processing sPLT chunk"); "Out of memory while processing sPLT chunk");
png_free(png_ptr, to->name); png_free(png_ptr, to->name);
to->name = NULL; to->name = NULL;
continue; continue;
} }
png_memcpy(to->entries, from->entries, png_memcpy(to->entries, from->entries,
from->nentries * png_sizeof(png_sPLT_entry)); from->nentries * png_sizeof(png_sPLT_entry));
to->nentries = from->nentries; to->nentries = from->nentries;
to->depth = from->depth; to->depth = from->depth;
} }
info_ptr->splt_palettes = np; info_ptr->splt_palettes = np;
info_ptr->splt_palettes_num += nentries; info_ptr->splt_palettes_num += nentries;
info_ptr->valid |= PNG_INFO_sPLT; info_ptr->valid |= PNG_INFO_sPLT;
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_SPLT; info_ptr->free_me |= PNG_FREE_SPLT;
#endif #endif
} }
#endif /* PNG_sPLT_SUPPORTED */ #endif /* PNG_sPLT_SUPPORTED */
@@ -1010,61 +1009,61 @@ void PNGAPI
png_set_unknown_chunks(png_structp png_ptr, png_set_unknown_chunks(png_structp png_ptr,
png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns) png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)
{ {
png_unknown_chunkp np; png_unknown_chunkp np;
int i; int i;
if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0) if (png_ptr == NULL || info_ptr == NULL || num_unknowns == 0)
return;
np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
(png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *
png_sizeof(png_unknown_chunk)));
if (np == NULL)
{
png_warning(png_ptr,
"Out of memory while processing unknown chunk.");
return; return;
}
png_memcpy(np, info_ptr->unknown_chunks, np = (png_unknown_chunkp)png_malloc_warn(png_ptr,
info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk)); (png_uint_32)((info_ptr->unknown_chunks_num + num_unknowns) *
png_free(png_ptr, info_ptr->unknown_chunks); png_sizeof(png_unknown_chunk)));
info_ptr->unknown_chunks=NULL; if (np == NULL)
{
png_warning(png_ptr,
"Out of memory while processing unknown chunk.");
return;
}
for (i = 0; i < num_unknowns; i++) png_memcpy(np, info_ptr->unknown_chunks,
{ info_ptr->unknown_chunks_num * png_sizeof(png_unknown_chunk));
png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i; png_free(png_ptr, info_ptr->unknown_chunks);
png_unknown_chunkp from = unknowns + i; info_ptr->unknown_chunks=NULL;
png_memcpy((png_charp)to->name, for (i = 0; i < num_unknowns; i++)
(png_charp)from->name, {
png_sizeof(from->name)); png_unknown_chunkp to = np + info_ptr->unknown_chunks_num + i;
to->name[png_sizeof(to->name)-1] = '\0'; png_unknown_chunkp from = unknowns + i;
to->size = from->size;
/* note our location in the read or write sequence */
to->location = (png_byte)(png_ptr->mode & 0xff);
if (from->size == 0) png_memcpy((png_charp)to->name,
to->data=NULL; (png_charp)from->name,
else png_sizeof(from->name));
{ to->name[png_sizeof(to->name)-1] = '\0';
to->data = (png_bytep)png_malloc_warn(png_ptr, to->size = from->size;
(png_uint_32)from->size); /* Note our location in the read or write sequence */
if (to->data == NULL) to->location = (png_byte)(png_ptr->mode & 0xff);
{
png_warning(png_ptr,
"Out of memory while processing unknown chunk.");
to->size = 0;
}
else
png_memcpy(to->data, from->data, from->size);
}
}
info_ptr->unknown_chunks = np; if (from->size == 0)
info_ptr->unknown_chunks_num += num_unknowns; to->data=NULL;
else
{
to->data = (png_bytep)png_malloc_warn(png_ptr,
(png_uint_32)from->size);
if (to->data == NULL)
{
png_warning(png_ptr,
"Out of memory while processing unknown chunk.");
to->size = 0;
}
else
png_memcpy(to->data, from->data, from->size);
}
}
info_ptr->unknown_chunks = np;
info_ptr->unknown_chunks_num += num_unknowns;
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
info_ptr->free_me |= PNG_FREE_UNKN; info_ptr->free_me |= PNG_FREE_UNKN;
#endif #endif
} }
void PNGAPI void PNGAPI
@@ -1113,44 +1112,44 @@ void PNGAPI
png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep png_set_keep_unknown_chunks(png_structp png_ptr, int keep, png_bytep
chunk_list, int num_chunks) chunk_list, int num_chunks)
{ {
png_bytep new_list, p; png_bytep new_list, p;
int i, old_num_chunks; int i, old_num_chunks;
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
if (num_chunks == 0) if (num_chunks == 0)
{ {
if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE) if (keep == PNG_HANDLE_CHUNK_ALWAYS || keep == PNG_HANDLE_CHUNK_IF_SAFE)
png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS; png_ptr->flags |= PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
else else
png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS; png_ptr->flags &= ~PNG_FLAG_KEEP_UNKNOWN_CHUNKS;
if (keep == PNG_HANDLE_CHUNK_ALWAYS) if (keep == PNG_HANDLE_CHUNK_ALWAYS)
png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS; png_ptr->flags |= PNG_FLAG_KEEP_UNSAFE_CHUNKS;
else else
png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS; png_ptr->flags &= ~PNG_FLAG_KEEP_UNSAFE_CHUNKS;
return; return;
} }
if (chunk_list == NULL) if (chunk_list == NULL)
return; return;
old_num_chunks = png_ptr->num_chunk_list; old_num_chunks = png_ptr->num_chunk_list;
new_list=(png_bytep)png_malloc(png_ptr, new_list=(png_bytep)png_malloc(png_ptr,
(png_uint_32) (png_uint_32)
(5*(num_chunks + old_num_chunks))); (5*(num_chunks + old_num_chunks)));
if (png_ptr->chunk_list != NULL) if (png_ptr->chunk_list != NULL)
{ {
png_memcpy(new_list, png_ptr->chunk_list, png_memcpy(new_list, png_ptr->chunk_list,
(png_size_t)(5*old_num_chunks)); (png_size_t)(5*old_num_chunks));
png_free(png_ptr, png_ptr->chunk_list); png_free(png_ptr, png_ptr->chunk_list);
png_ptr->chunk_list=NULL; png_ptr->chunk_list=NULL;
} }
png_memcpy(new_list + 5*old_num_chunks, chunk_list, png_memcpy(new_list + 5*old_num_chunks, chunk_list,
(png_size_t)(5*num_chunks)); (png_size_t)(5*num_chunks));
for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5) for (p = new_list + 5*old_num_chunks + 4, i = 0; i<num_chunks; i++, p += 5)
*p=(png_byte)keep; *p=(png_byte)keep;
png_ptr->num_chunk_list = old_num_chunks + num_chunks; png_ptr->num_chunk_list = old_num_chunks + num_chunks;
png_ptr->chunk_list = new_list; png_ptr->chunk_list = new_list;
#ifdef PNG_FREE_ME_SUPPORTED #ifdef PNG_FREE_ME_SUPPORTED
png_ptr->free_me |= PNG_FREE_LIST; png_ptr->free_me |= PNG_FREE_LIST;
#endif #endif
} }
#endif #endif
@@ -1210,7 +1209,7 @@ png_set_invalid(png_structp png_ptr, png_infop info_ptr, int mask)
#ifndef PNG_1_0_X #ifndef PNG_1_0_X
#ifdef PNG_ASSEMBLER_CODE_SUPPORTED #ifdef PNG_ASSEMBLER_CODE_SUPPORTED
/* function was added to libpng 1.2.0 and should always exist by default */ /* Function was added to libpng 1.2.0 and should always exist by default */
void PNGAPI void PNGAPI
png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags) png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
{ {
@@ -1220,7 +1219,7 @@ png_set_asm_flags (png_structp png_ptr, png_uint_32 asm_flags)
asm_flags = asm_flags; /* Quiet the compiler */ asm_flags = asm_flags; /* Quiet the compiler */
} }
/* this function was added to libpng 1.2.0 */ /* This function was added to libpng 1.2.0 */
void PNGAPI void PNGAPI
png_set_mmx_thresholds (png_structp png_ptr, png_set_mmx_thresholds (png_structp png_ptr,
png_byte mmx_bitdepth_threshold, png_byte mmx_bitdepth_threshold,
@@ -1236,18 +1235,19 @@ png_set_mmx_thresholds (png_structp png_ptr,
#endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */ #endif /* ?PNG_ASSEMBLER_CODE_SUPPORTED */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
/* this function was added to libpng 1.2.6 */ /* This function was added to libpng 1.2.6 */
void PNGAPI void PNGAPI
png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max, png_set_user_limits (png_structp png_ptr, png_uint_32 user_width_max,
png_uint_32 user_height_max) png_uint_32 user_height_max)
{ {
/* Images with dimensions larger than these limits will be /* Images with dimensions larger than these limits will be
* rejected by png_set_IHDR(). To accept any PNG datastream * rejected by png_set_IHDR(). To accept any PNG datastream
* regardless of dimensions, set both limits to 0x7ffffffL. * regardless of dimensions, set both limits to 0x7ffffffL.
*/ */
if (png_ptr == NULL) return; if (png_ptr == NULL)
png_ptr->user_width_max = user_width_max; return;
png_ptr->user_height_max = user_height_max; png_ptr->user_width_max = user_width_max;
png_ptr->user_height_max = user_height_max;
} }
#endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */ #endif /* ?PNG_SET_USER_LIMITS_SUPPORTED */
src/libs/png/pngtrans.c
+38 -26
View File
@@ -1,9 +1,9 @@
/* pngtrans.c - transforms the data in a row (used by both readers and writers) /* pngtrans.c - transforms the data in a row (used by both readers and writers)
* *
* Last changed in libpng 1.2.30 [August 15, 2008] * Last changed in libpng 1.2.36 [May 14, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@@ -13,35 +13,38 @@
#if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED) #if defined(PNG_READ_SUPPORTED) || defined(PNG_WRITE_SUPPORTED)
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* turn on BGR-to-RGB mapping */ /* Turn on BGR-to-RGB mapping */
void PNGAPI void PNGAPI
png_set_bgr(png_structp png_ptr) png_set_bgr(png_structp png_ptr)
{ {
png_debug(1, "in png_set_bgr"); png_debug(1, "in png_set_bgr");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_BGR; png_ptr->transformations |= PNG_BGR;
} }
#endif #endif
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* turn on 16 bit byte swapping */ /* Turn on 16 bit byte swapping */
void PNGAPI void PNGAPI
png_set_swap(png_structp png_ptr) png_set_swap(png_structp png_ptr)
{ {
png_debug(1, "in png_set_swap"); png_debug(1, "in png_set_swap");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (png_ptr->bit_depth == 16) if (png_ptr->bit_depth == 16)
png_ptr->transformations |= PNG_SWAP_BYTES; png_ptr->transformations |= PNG_SWAP_BYTES;
} }
#endif #endif
#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) #if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED)
/* turn on pixel packing */ /* Turn on pixel packing */
void PNGAPI void PNGAPI
png_set_packing(png_structp png_ptr) png_set_packing(png_structp png_ptr)
{ {
png_debug(1, "in png_set_packing"); png_debug(1, "in png_set_packing");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (png_ptr->bit_depth < 8) if (png_ptr->bit_depth < 8)
{ {
png_ptr->transformations |= PNG_PACK; png_ptr->transformations |= PNG_PACK;
@@ -51,12 +54,13 @@ png_set_packing(png_structp png_ptr)
#endif #endif
#if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED) #if defined(PNG_READ_PACKSWAP_SUPPORTED)||defined(PNG_WRITE_PACKSWAP_SUPPORTED)
/* turn on packed pixel swapping */ /* Turn on packed pixel swapping */
void PNGAPI void PNGAPI
png_set_packswap(png_structp png_ptr) png_set_packswap(png_structp png_ptr)
{ {
png_debug(1, "in png_set_packswap"); png_debug(1, "in png_set_packswap");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
if (png_ptr->bit_depth < 8) if (png_ptr->bit_depth < 8)
png_ptr->transformations |= PNG_PACKSWAP; png_ptr->transformations |= PNG_PACKSWAP;
} }
@@ -67,7 +71,8 @@ void PNGAPI
png_set_shift(png_structp png_ptr, png_color_8p true_bits) png_set_shift(png_structp png_ptr, png_color_8p true_bits)
{ {
png_debug(1, "in png_set_shift"); png_debug(1, "in png_set_shift");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_SHIFT; png_ptr->transformations |= PNG_SHIFT;
png_ptr->shift = *true_bits; png_ptr->shift = *true_bits;
} }
@@ -99,7 +104,8 @@ void PNGAPI
png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc) png_set_filler(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{ {
png_debug(1, "in png_set_filler"); png_debug(1, "in png_set_filler");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_FILLER; png_ptr->transformations |= PNG_FILLER;
png_ptr->filler = (png_byte)filler; png_ptr->filler = (png_byte)filler;
if (filler_loc == PNG_FILLER_AFTER) if (filler_loc == PNG_FILLER_AFTER)
@@ -132,7 +138,8 @@ void PNGAPI
png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc) png_set_add_alpha(png_structp png_ptr, png_uint_32 filler, int filler_loc)
{ {
png_debug(1, "in png_set_add_alpha"); png_debug(1, "in png_set_add_alpha");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_set_filler(png_ptr, filler, filler_loc); png_set_filler(png_ptr, filler, filler_loc);
png_ptr->transformations |= PNG_ADD_ALPHA; png_ptr->transformations |= PNG_ADD_ALPHA;
} }
@@ -146,7 +153,8 @@ void PNGAPI
png_set_swap_alpha(png_structp png_ptr) png_set_swap_alpha(png_structp png_ptr)
{ {
png_debug(1, "in png_set_swap_alpha"); png_debug(1, "in png_set_swap_alpha");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_SWAP_ALPHA; png_ptr->transformations |= PNG_SWAP_ALPHA;
} }
#endif #endif
@@ -157,7 +165,8 @@ void PNGAPI
png_set_invert_alpha(png_structp png_ptr) png_set_invert_alpha(png_structp png_ptr)
{ {
png_debug(1, "in png_set_invert_alpha"); png_debug(1, "in png_set_invert_alpha");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_INVERT_ALPHA; png_ptr->transformations |= PNG_INVERT_ALPHA;
} }
#endif #endif
@@ -167,11 +176,12 @@ void PNGAPI
png_set_invert_mono(png_structp png_ptr) png_set_invert_mono(png_structp png_ptr)
{ {
png_debug(1, "in png_set_invert_mono"); png_debug(1, "in png_set_invert_mono");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->transformations |= PNG_INVERT_MONO; png_ptr->transformations |= PNG_INVERT_MONO;
} }
/* invert monochrome grayscale data */ /* Invert monochrome grayscale data */
void /* PRIVATE */ void /* PRIVATE */
png_do_invert(png_row_infop row_info, png_bytep row) png_do_invert(png_row_infop row_info, png_bytep row)
{ {
@@ -226,7 +236,7 @@ png_do_invert(png_row_infop row_info, png_bytep row)
#endif #endif
#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) #if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED)
/* swaps byte order on 16 bit depth images */ /* Swaps byte order on 16 bit depth images */
void /* PRIVATE */ void /* PRIVATE */
png_do_swap(png_row_infop row_info, png_bytep row) png_do_swap(png_row_infop row_info, png_bytep row)
{ {
@@ -357,7 +367,7 @@ static PNG_CONST png_byte fourbppswaptable[256] = {
0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF 0x8F, 0x9F, 0xAF, 0xBF, 0xCF, 0xDF, 0xEF, 0xFF
}; };
/* swaps pixel packing order within bytes */ /* Swaps pixel packing order within bytes */
void /* PRIVATE */ void /* PRIVATE */
png_do_packswap(png_row_infop row_info, png_bytep row) png_do_packswap(png_row_infop row_info, png_bytep row)
{ {
@@ -389,7 +399,7 @@ png_do_packswap(png_row_infop row_info, png_bytep row)
#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ #if defined(PNG_WRITE_FILLER_SUPPORTED) || \
defined(PNG_READ_STRIP_ALPHA_SUPPORTED) defined(PNG_READ_STRIP_ALPHA_SUPPORTED)
/* remove filler or alpha byte(s) */ /* Remove filler or alpha byte(s) */
void /* PRIVATE */ void /* PRIVATE */
png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags) png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
{ {
@@ -404,9 +414,9 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
png_uint_32 i; png_uint_32 i;
if ((row_info->color_type == PNG_COLOR_TYPE_RGB || if ((row_info->color_type == PNG_COLOR_TYPE_RGB ||
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA && (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA &&
(flags & PNG_FLAG_STRIP_ALPHA))) && (flags & PNG_FLAG_STRIP_ALPHA))) &&
row_info->channels == 4) row_info->channels == 4)
{ {
if (row_info->bit_depth == 8) if (row_info->bit_depth == 8)
{ {
@@ -547,7 +557,7 @@ png_do_strip_filler(png_row_infop row_info, png_bytep row, png_uint_32 flags)
#endif #endif
#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) #if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED)
/* swaps red and blue bytes within a pixel */ /* Swaps red and blue bytes within a pixel */
void /* PRIVATE */ void /* PRIVATE */
png_do_bgr(png_row_infop row_info, png_bytep row) png_do_bgr(png_row_infop row_info, png_bytep row)
{ {
@@ -631,7 +641,8 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp
user_transform_ptr, int user_transform_depth, int user_transform_channels) user_transform_ptr, int user_transform_depth, int user_transform_channels)
{ {
png_debug(1, "in png_set_user_transform_info"); png_debug(1, "in png_set_user_transform_info");
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
png_ptr->user_transform_ptr = user_transform_ptr; png_ptr->user_transform_ptr = user_transform_ptr;
png_ptr->user_transform_depth = (png_byte)user_transform_depth; png_ptr->user_transform_depth = (png_byte)user_transform_depth;
@@ -652,7 +663,8 @@ png_set_user_transform_info(png_structp png_ptr, png_voidp
png_voidp PNGAPI png_voidp PNGAPI
png_get_user_transform_ptr(png_structp png_ptr) png_get_user_transform_ptr(png_structp png_ptr)
{ {
if (png_ptr == NULL) return (NULL); if (png_ptr == NULL)
return (NULL);
#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) #if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
return ((png_voidp)png_ptr->user_transform_ptr); return ((png_voidp)png_ptr->user_transform_ptr);
#else #else
src/libs/png/pngwio.c
+64 -42
View File
@@ -1,7 +1,7 @@
/* pngwio.c - functions for data output /* pngwio.c - functions for data output
* *
* Last changed in libpng 1.2.35 [February 14, 2009] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2009 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -20,10 +20,11 @@
#ifdef PNG_WRITE_SUPPORTED #ifdef PNG_WRITE_SUPPORTED
/* Write the data to whatever output you are using. The default routine /* Write the data to whatever output you are using. The default routine
writes to a file pointer. Note that this routine sometimes gets called * writes to a file pointer. Note that this routine sometimes gets called
with very small lengths, so you should implement some kind of simple * with very small lengths, so you should implement some kind of simple
buffering if you are using unbuffered writes. This should never be asked * buffering if you are using unbuffered writes. This should never be asked
to write more than 64K on a 16 bit machine. */ * to write more than 64K on a 16 bit machine.
*/
void /* PRIVATE */ void /* PRIVATE */
png_write_data(png_structp png_ptr, png_bytep data, png_size_t length) png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
@@ -36,16 +37,18 @@ png_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
/* This is the function that does the actual writing of data. If you are /* This is the function that does the actual writing of data. If you are
not writing to a standard C stream, you should create a replacement * not writing to a standard C stream, you should create a replacement
write_data function and use it at run time with png_set_write_fn(), rather * write_data function and use it at run time with png_set_write_fn(), rather
than changing the library. */ * than changing the library.
*/
#ifndef USE_FAR_KEYWORD #ifndef USE_FAR_KEYWORD
void PNGAPI void PNGAPI
png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length) png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
{ {
png_uint_32 check; png_uint_32 check;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if defined(_WIN32_WCE) #if defined(_WIN32_WCE)
if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) ) if ( !WriteFile((HANDLE)(png_ptr->io_ptr), data, length, &check, NULL) )
check = 0; check = 0;
@@ -56,10 +59,10 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_error(png_ptr, "Write Error"); png_error(png_ptr, "Write Error");
} }
#else #else
/* this is the model-independent version. Since the standard I/O library /* This is the model-independent version. Since the standard I/O library
can't handle far buffers in the medium and small models, we have to copy * can't handle far buffers in the medium and small models, we have to copy
the data. * the data.
*/ */
#define NEAR_BUF_SIZE 1024 #define NEAR_BUF_SIZE 1024
#define MIN(a,b) (a <= b ? a : b) #define MIN(a,b) (a <= b ? a : b)
@@ -71,7 +74,8 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */ png_byte *near_data; /* Needs to be "png_byte *" instead of "png_bytep" */
png_FILE_p io_ptr; png_FILE_p io_ptr;
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
/* Check if data really is near. If so, use usual code. */ /* Check if data really is near. If so, use usual code. */
near_data = (png_byte *)CVT_PTR_NOCHECK(data); near_data = (png_byte *)CVT_PTR_NOCHECK(data);
io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr); io_ptr = (png_FILE_p)CVT_PTR(png_ptr->io_ptr);
@@ -93,7 +97,7 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
do do
{ {
written = MIN(NEAR_BUF_SIZE, remaining); written = MIN(NEAR_BUF_SIZE, remaining);
png_memcpy(buf, data, written); /* copy far buffer to near buffer */ png_memcpy(buf, data, written); /* Copy far buffer to near buffer */
#if defined(_WIN32_WCE) #if defined(_WIN32_WCE)
if ( !WriteFile(io_ptr, buf, written, &err, NULL) ) if ( !WriteFile(io_ptr, buf, written, &err, NULL) )
err = 0; err = 0;
@@ -102,8 +106,10 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
#endif #endif
if (err != written) if (err != written)
break; break;
else else
check += err; check += err;
data += written; data += written;
remaining -= written; remaining -= written;
} }
@@ -117,8 +123,9 @@ png_default_write_data(png_structp png_ptr, png_bytep data, png_size_t length)
#endif #endif
/* This function is called to output any data pending writing (normally /* This function is called to output any data pending writing (normally
to disk). After png_flush is called, there should be no data pending * to disk). After png_flush is called, there should be no data pending
writing in any buffers. */ * writing in any buffers.
*/
#if defined(PNG_WRITE_FLUSH_SUPPORTED) #if defined(PNG_WRITE_FLUSH_SUPPORTED)
void /* PRIVATE */ void /* PRIVATE */
png_flush(png_structp png_ptr) png_flush(png_structp png_ptr)
@@ -134,48 +141,58 @@ png_default_flush(png_structp png_ptr)
#if !defined(_WIN32_WCE) #if !defined(_WIN32_WCE)
png_FILE_p io_ptr; png_FILE_p io_ptr;
#endif #endif
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
#if !defined(_WIN32_WCE) #if !defined(_WIN32_WCE)
io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr)); io_ptr = (png_FILE_p)CVT_PTR((png_ptr->io_ptr));
if (io_ptr != NULL && fileno(io_ptr) != -1) fflush(io_ptr);
fflush(io_ptr);
#endif #endif
} }
#endif #endif
#endif #endif
/* This function allows the application to supply new output functions for /* This function allows the application to supply new output functions for
libpng if standard C streams aren't being used. * libpng if standard C streams aren't being used.
*
This function takes as its arguments: * This function takes as its arguments:
png_ptr - pointer to a png output data structure * png_ptr - pointer to a png output data structure
io_ptr - pointer to user supplied structure containing info about * io_ptr - pointer to user supplied structure containing info about
the output functions. May be NULL. * the output functions. May be NULL.
write_data_fn - pointer to a new output function that takes as its * write_data_fn - pointer to a new output function that takes as its
arguments a pointer to a png_struct, a pointer to * arguments a pointer to a png_struct, a pointer to
data to be written, and a 32-bit unsigned int that is * data to be written, and a 32-bit unsigned int that is
the number of bytes to be written. The new write * the number of bytes to be written. The new write
function should call png_error(png_ptr, "Error msg") * function should call png_error(png_ptr, "Error msg")
to exit and output any fatal error messages. * to exit and output any fatal error messages. May be
flush_data_fn - pointer to a new flush function that takes as its * NULL, in which case libpng's default function will
arguments a pointer to a png_struct. After a call to * be used.
the flush function, there should be no data in any buffers * flush_data_fn - pointer to a new flush function that takes as its
or pending transmission. If the output method doesn't do * arguments a pointer to a png_struct. After a call to
any buffering of ouput, a function prototype must still be * the flush function, there should be no data in any buffers
supplied although it doesn't have to do anything. If * or pending transmission. If the output method doesn't do
PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile * any buffering of ouput, a function prototype must still be
time, output_flush_fn will be ignored, although it must be * supplied although it doesn't have to do anything. If
supplied for compatibility. */ * PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile
* time, output_flush_fn will be ignored, although it must be
* supplied for compatibility. May be NULL, in which case
* libpng's default function will be used, if
* PNG_WRITE_FLUSH_SUPPORTED is defined. This is not
* a good idea if io_ptr does not point to a standard
* *FILE structure.
*/
void PNGAPI void PNGAPI
png_set_write_fn(png_structp png_ptr, png_voidp io_ptr, png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn) png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)
{ {
if (png_ptr == NULL) return; if (png_ptr == NULL)
return;
png_ptr->io_ptr = io_ptr; png_ptr->io_ptr = io_ptr;
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
if (write_data_fn != NULL) if (write_data_fn != NULL)
png_ptr->write_data_fn = write_data_fn; png_ptr->write_data_fn = write_data_fn;
else else
png_ptr->write_data_fn = png_default_write_data; png_ptr->write_data_fn = png_default_write_data;
#else #else
@@ -186,6 +203,7 @@ png_set_write_fn(png_structp png_ptr, png_voidp io_ptr,
#if !defined(PNG_NO_STDIO) #if !defined(PNG_NO_STDIO)
if (output_flush_fn != NULL) if (output_flush_fn != NULL)
png_ptr->output_flush_fn = output_flush_fn; png_ptr->output_flush_fn = output_flush_fn;
else else
png_ptr->output_flush_fn = png_default_flush; png_ptr->output_flush_fn = png_default_flush;
#else #else
@@ -212,9 +230,11 @@ void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
void FAR *far_ptr; void FAR *far_ptr;
FP_OFF(near_ptr) = FP_OFF(ptr); FP_OFF(near_ptr) = FP_OFF(ptr);
far_ptr = (void FAR *)near_ptr; far_ptr = (void FAR *)near_ptr;
if (check != 0) if (check != 0)
if (FP_SEG(ptr) != FP_SEG(far_ptr)) if (FP_SEG(ptr) != FP_SEG(far_ptr))
png_error(png_ptr, "segment lost in conversion"); png_error(png_ptr, "segment lost in conversion");
return(near_ptr); return(near_ptr);
} }
# else # else
@@ -224,9 +244,11 @@ void *png_far_to_near(png_structp png_ptr, png_voidp ptr, int check)
void FAR *far_ptr; void FAR *far_ptr;
near_ptr = (void FAR *)ptr; near_ptr = (void FAR *)ptr;
far_ptr = (void FAR *)near_ptr; far_ptr = (void FAR *)near_ptr;
if (check != 0) if (check != 0)
if (far_ptr != ptr) if (far_ptr != ptr)
png_error(png_ptr, "segment lost in conversion"); png_error(png_ptr, "segment lost in conversion");
return(near_ptr); return(near_ptr);
} }
# endif # endif
src/libs/png/pngwrite.c
+135 -124
View File
@@ -1,14 +1,14 @@
/* pngwrite.c - general routines to write a PNG file /* pngwrite.c - general routines to write a PNG file
* *
* Last changed in libpng 1.2.34 [December 18, 2008] * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2008 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
/* get internal access to png.h */ /* Get internal access to png.h */
#define PNG_INTERNAL #define PNG_INTERNAL
#include "png.h" #include "png.h"
#ifdef PNG_WRITE_SUPPORTED #ifdef PNG_WRITE_SUPPORTED
@@ -30,7 +30,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
return; return;
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
{ {
png_write_sig(png_ptr); /* write PNG signature */ png_write_sig(png_ptr); /* Write PNG signature */
#if defined(PNG_MNG_FEATURES_SUPPORTED) #if defined(PNG_MNG_FEATURES_SUPPORTED)
if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted)) if ((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))
{ {
@@ -38,7 +38,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
png_ptr->mng_features_permitted=0; png_ptr->mng_features_permitted=0;
} }
#endif #endif
/* write IHDR information. */ /* Write IHDR information. */
png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
info_ptr->filter_type, info_ptr->filter_type,
@@ -47,8 +47,9 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
#else #else
0); 0);
#endif #endif
/* the rest of these check to see if the valid field has the appropriate /* The rest of these check to see if the valid field has the appropriate
flag set, and if it does, writes the chunk. */ * flag set, and if it does, writes the chunk.
*/
#if defined(PNG_WRITE_gAMA_SUPPORTED) #if defined(PNG_WRITE_gAMA_SUPPORTED)
if (info_ptr->valid & PNG_INFO_gAMA) if (info_ptr->valid & PNG_INFO_gAMA)
{ {
@@ -97,14 +98,14 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
if (info_ptr->unknown_chunks_num) if (info_ptr->unknown_chunks_num)
{ {
png_unknown_chunk *up; png_unknown_chunk *up;
png_debug(5, "writing extra chunks"); png_debug(5, "writing extra chunks");
for (up = info_ptr->unknown_chunks; for (up = info_ptr->unknown_chunks;
up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num; up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
up++) up++)
{ {
int keep=png_handle_as_unknown(png_ptr, up->name); int keep=png_handle_as_unknown(png_ptr, up->name);
if (keep != PNG_HANDLE_CHUNK_NEVER && if (keep != PNG_HANDLE_CHUNK_NEVER &&
up->location && !(up->location & PNG_HAVE_PLTE) && up->location && !(up->location & PNG_HAVE_PLTE) &&
@@ -116,7 +117,7 @@ png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
png_warning(png_ptr, "Writing zero-length unknown chunk"); png_warning(png_ptr, "Writing zero-length unknown chunk");
png_write_chunk(png_ptr, up->name, up->data, up->size); png_write_chunk(png_ptr, up->name, up->data, up->size);
} }
} }
} }
#endif #endif
png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
@@ -145,20 +146,20 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
#if defined(PNG_WRITE_tRNS_SUPPORTED) #if defined(PNG_WRITE_tRNS_SUPPORTED)
if (info_ptr->valid & PNG_INFO_tRNS) if (info_ptr->valid & PNG_INFO_tRNS)
{ {
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel (in tRNS) */ /* Invert the alpha channel (in tRNS) */
if ((png_ptr->transformations & PNG_INVERT_ALPHA) && if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
{ {
int j; int j;
for (j=0; j<(int)info_ptr->num_trans; j++) for (j=0; j<(int)info_ptr->num_trans; j++)
info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]); info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);
} }
#endif #endif
png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values), png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),
info_ptr->num_trans, info_ptr->color_type); info_ptr->num_trans, info_ptr->color_type);
} }
#endif #endif
#if defined(PNG_WRITE_bKGD_SUPPORTED) #if defined(PNG_WRITE_bKGD_SUPPORTED)
if (info_ptr->valid & PNG_INFO_bKGD) if (info_ptr->valid & PNG_INFO_bKGD)
@@ -179,49 +180,56 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams, info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
info_ptr->pcal_units, info_ptr->pcal_params); info_ptr->pcal_units, info_ptr->pcal_params);
#endif #endif
#if defined(PNG_WRITE_sCAL_SUPPORTED)
#if defined(PNG_sCAL_SUPPORTED)
if (info_ptr->valid & PNG_INFO_sCAL) if (info_ptr->valid & PNG_INFO_sCAL)
#if defined(PNG_WRITE_sCAL_SUPPORTED)
#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) #if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
png_write_sCAL(png_ptr, (int)info_ptr->scal_unit, png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
info_ptr->scal_pixel_width, info_ptr->scal_pixel_height); info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);
#else #else /* !FLOATING_POINT */
#ifdef PNG_FIXED_POINT_SUPPORTED #ifdef PNG_FIXED_POINT_SUPPORTED
png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit, png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
info_ptr->scal_s_width, info_ptr->scal_s_height); info_ptr->scal_s_width, info_ptr->scal_s_height);
#else #endif /* FIXED_POINT */
#endif /* FLOATING_POINT */
#else /* !WRITE_sCAL */
png_warning(png_ptr, png_warning(png_ptr,
"png_write_sCAL not supported; sCAL chunk not written."); "png_write_sCAL not supported; sCAL chunk not written.");
#endif #endif /* WRITE_sCAL */
#endif #endif /* sCAL */
#endif
#if defined(PNG_WRITE_pHYs_SUPPORTED) #if defined(PNG_WRITE_pHYs_SUPPORTED)
if (info_ptr->valid & PNG_INFO_pHYs) if (info_ptr->valid & PNG_INFO_pHYs)
png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit, png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type); info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
#endif #endif /* pHYs */
#if defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_WRITE_tIME_SUPPORTED)
if (info_ptr->valid & PNG_INFO_tIME) if (info_ptr->valid & PNG_INFO_tIME)
{ {
png_write_tIME(png_ptr, &(info_ptr->mod_time)); png_write_tIME(png_ptr, &(info_ptr->mod_time));
png_ptr->mode |= PNG_WROTE_tIME; png_ptr->mode |= PNG_WROTE_tIME;
} }
#endif #endif /* tIME */
#if defined(PNG_WRITE_sPLT_SUPPORTED) #if defined(PNG_WRITE_sPLT_SUPPORTED)
if (info_ptr->valid & PNG_INFO_sPLT) if (info_ptr->valid & PNG_INFO_sPLT)
for (i = 0; i < (int)info_ptr->splt_palettes_num; i++) for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
png_write_sPLT(png_ptr, info_ptr->splt_palettes + i); png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
#endif #endif /* sPLT */
#if defined(PNG_WRITE_TEXT_SUPPORTED) #if defined(PNG_WRITE_TEXT_SUPPORTED)
/* Check to see if we need to write text chunks */ /* Check to see if we need to write text chunks */
for (i = 0; i < info_ptr->num_text; i++) for (i = 0; i < info_ptr->num_text; i++)
{ {
png_debug2(2, "Writing header text chunk %d, type %d", i, png_debug2(2, "Writing header text chunk %d, type %d", i,
info_ptr->text[i].compression); info_ptr->text[i].compression);
/* an internationalized chunk? */ /* An internationalized chunk? */
if (info_ptr->text[i].compression > 0) if (info_ptr->text[i].compression > 0)
{ {
#if defined(PNG_WRITE_iTXt_SUPPORTED) #if defined(PNG_WRITE_iTXt_SUPPORTED)
/* write international chunk */ /* Write international chunk */
png_write_iTXt(png_ptr, png_write_iTXt(png_ptr,
info_ptr->text[i].compression, info_ptr->text[i].compression,
info_ptr->text[i].key, info_ptr->text[i].key,
@@ -238,7 +246,7 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt) else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
{ {
#if defined(PNG_WRITE_zTXt_SUPPORTED) #if defined(PNG_WRITE_zTXt_SUPPORTED)
/* write compressed chunk */ /* Write compressed chunk */
png_write_zTXt(png_ptr, info_ptr->text[i].key, png_write_zTXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, 0, info_ptr->text[i].text, 0,
info_ptr->text[i].compression); info_ptr->text[i].compression);
@@ -251,18 +259,20 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
{ {
#if defined(PNG_WRITE_tEXt_SUPPORTED) #if defined(PNG_WRITE_tEXt_SUPPORTED)
/* write uncompressed chunk */ /* Write uncompressed chunk */
png_write_tEXt(png_ptr, info_ptr->text[i].key, png_write_tEXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, info_ptr->text[i].text,
0); 0);
#else
png_warning(png_ptr, "Unable to write uncompressed text");
#endif
/* Mark this chunk as written */ /* Mark this chunk as written */
info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR; info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
#else
/* Can't get here */
png_warning(png_ptr, "Unable to write uncompressed text");
#endif
} }
} }
#endif #endif /* tEXt */
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
if (info_ptr->unknown_chunks_num) if (info_ptr->unknown_chunks_num)
{ {
@@ -302,29 +312,29 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
if (!(png_ptr->mode & PNG_HAVE_IDAT)) if (!(png_ptr->mode & PNG_HAVE_IDAT))
png_error(png_ptr, "No IDATs written into file"); png_error(png_ptr, "No IDATs written into file");
/* see if user wants us to write information chunks */ /* See if user wants us to write information chunks */
if (info_ptr != NULL) if (info_ptr != NULL)
{ {
#if defined(PNG_WRITE_TEXT_SUPPORTED) #if defined(PNG_WRITE_TEXT_SUPPORTED)
int i; /* local index variable */ int i; /* Local index variable */
#endif #endif
#if defined(PNG_WRITE_tIME_SUPPORTED) #if defined(PNG_WRITE_tIME_SUPPORTED)
/* check to see if user has supplied a time chunk */ /* Check to see if user has supplied a time chunk */
if ((info_ptr->valid & PNG_INFO_tIME) && if ((info_ptr->valid & PNG_INFO_tIME) &&
!(png_ptr->mode & PNG_WROTE_tIME)) !(png_ptr->mode & PNG_WROTE_tIME))
png_write_tIME(png_ptr, &(info_ptr->mod_time)); png_write_tIME(png_ptr, &(info_ptr->mod_time));
#endif #endif
#if defined(PNG_WRITE_TEXT_SUPPORTED) #if defined(PNG_WRITE_TEXT_SUPPORTED)
/* loop through comment chunks */ /* Loop through comment chunks */
for (i = 0; i < info_ptr->num_text; i++) for (i = 0; i < info_ptr->num_text; i++)
{ {
png_debug2(2, "Writing trailer text chunk %d, type %d", i, png_debug2(2, "Writing trailer text chunk %d, type %d", i,
info_ptr->text[i].compression); info_ptr->text[i].compression);
/* an internationalized chunk? */ /* An internationalized chunk? */
if (info_ptr->text[i].compression > 0) if (info_ptr->text[i].compression > 0)
{ {
#if defined(PNG_WRITE_iTXt_SUPPORTED) #if defined(PNG_WRITE_iTXt_SUPPORTED)
/* write international chunk */ /* Write international chunk */
png_write_iTXt(png_ptr, png_write_iTXt(png_ptr,
info_ptr->text[i].compression, info_ptr->text[i].compression,
info_ptr->text[i].key, info_ptr->text[i].key,
@@ -340,7 +350,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt) else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
{ {
#if defined(PNG_WRITE_zTXt_SUPPORTED) #if defined(PNG_WRITE_zTXt_SUPPORTED)
/* write compressed chunk */ /* Write compressed chunk */
png_write_zTXt(png_ptr, info_ptr->text[i].key, png_write_zTXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, 0, info_ptr->text[i].text, 0,
info_ptr->text[i].compression); info_ptr->text[i].compression);
@@ -353,7 +363,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE) else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
{ {
#if defined(PNG_WRITE_tEXt_SUPPORTED) #if defined(PNG_WRITE_tEXt_SUPPORTED)
/* write uncompressed chunk */ /* Write uncompressed chunk */
png_write_tEXt(png_ptr, info_ptr->text[i].key, png_write_tEXt(png_ptr, info_ptr->text[i].key,
info_ptr->text[i].text, 0); info_ptr->text[i].text, 0);
#else #else
@@ -391,7 +401,7 @@ png_write_end(png_structp png_ptr, png_infop info_ptr)
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
/* write end of PNG file */ /* Write end of PNG file */
png_write_IEND(png_ptr); png_write_IEND(png_ptr);
/* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03, /* This flush, added in libpng-1.0.8, removed from libpng-1.0.9beta03,
* and restored again in libpng-1.2.30, may cause some applications that * and restored again in libpng-1.2.30, may cause some applications that
@@ -471,7 +481,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
if (png_ptr == NULL) if (png_ptr == NULL)
return (NULL); return (NULL);
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
@@ -542,7 +552,7 @@ png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
} }
} }
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@@ -636,7 +646,7 @@ png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
{ {
png_structp png_ptr=*ptr_ptr; png_structp png_ptr=*ptr_ptr;
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
jmp_buf tmp_jmp; /* to save current jump buffer */ jmp_buf tmp_jmp; /* To save current jump buffer */
#endif #endif
int i = 0; int i = 0;
@@ -662,7 +672,7 @@ png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
png_debug(1, "in png_write_init_3"); png_debug(1, "in png_write_init_3");
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* save jump buffer and error functions */ /* Save jump buffer and error functions */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
#endif #endif
@@ -673,24 +683,24 @@ png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
*ptr_ptr = png_ptr; *ptr_ptr = png_ptr;
} }
/* reset all variables to 0 */ /* Reset all variables to 0 */
png_memset(png_ptr, 0, png_sizeof(png_struct)); png_memset(png_ptr, 0, png_sizeof(png_struct));
/* added at libpng-1.2.6 */ /* Added at libpng-1.2.6 */
#ifdef PNG_SET_USER_LIMITS_SUPPORTED #ifdef PNG_SET_USER_LIMITS_SUPPORTED
png_ptr->user_width_max=PNG_USER_WIDTH_MAX; png_ptr->user_width_max=PNG_USER_WIDTH_MAX;
png_ptr->user_height_max=PNG_USER_HEIGHT_MAX; png_ptr->user_height_max=PNG_USER_HEIGHT_MAX;
#endif #endif
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* restore jump buffer */ /* Restore jump buffer */
png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf)); png_memcpy(png_ptr->jmpbuf, tmp_jmp, png_sizeof(jmp_buf));
#endif #endif
png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL, png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
png_flush_ptr_NULL); png_flush_ptr_NULL);
/* initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
(png_uint_32)png_ptr->zbuf_size); (png_uint_32)png_ptr->zbuf_size);
@@ -710,15 +720,15 @@ void PNGAPI
png_write_rows(png_structp png_ptr, png_bytepp row, png_write_rows(png_structp png_ptr, png_bytepp row,
png_uint_32 num_rows) png_uint_32 num_rows)
{ {
png_uint_32 i; /* row counter */ png_uint_32 i; /* Row counter */
png_bytepp rp; /* row pointer */ png_bytepp rp; /* Row pointer */
png_debug(1, "in png_write_rows"); png_debug(1, "in png_write_rows");
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
/* loop through the rows */ /* Loop through the rows */
for (i = 0, rp = row; i < num_rows; i++, rp++) for (i = 0, rp = row; i < num_rows; i++, rp++)
{ {
png_write_row(png_ptr, *rp); png_write_row(png_ptr, *rp);
@@ -731,25 +741,26 @@ png_write_rows(png_structp png_ptr, png_bytepp row,
void PNGAPI void PNGAPI
png_write_image(png_structp png_ptr, png_bytepp image) png_write_image(png_structp png_ptr, png_bytepp image)
{ {
png_uint_32 i; /* row index */ png_uint_32 i; /* Row index */
int pass, num_pass; /* pass variables */ int pass, num_pass; /* Pass variables */
png_bytepp rp; /* points to current row */ png_bytepp rp; /* Points to current row */
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
png_debug(1, "in png_write_image"); png_debug(1, "in png_write_image");
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* intialize interlace handling. If image is not interlaced, /* Initialize interlace handling. If image is not interlaced,
this will set pass to 1 */ * this will set pass to 1
*/
num_pass = png_set_interlace_handling(png_ptr); num_pass = png_set_interlace_handling(png_ptr);
#else #else
num_pass = 1; num_pass = 1;
#endif #endif
/* loop through passes */ /* Loop through passes */
for (pass = 0; pass < num_pass; pass++) for (pass = 0; pass < num_pass; pass++)
{ {
/* loop through image */ /* Loop through image */
for (i = 0, rp = image; i < png_ptr->height; i++, rp++) for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
{ {
png_write_row(png_ptr, *rp); png_write_row(png_ptr, *rp);
@@ -757,7 +768,7 @@ png_write_image(png_structp png_ptr, png_bytepp image)
} }
} }
/* called by user to write a row of image data */ /* Called by user to write a row of image data */
void PNGAPI void PNGAPI
png_write_row(png_structp png_ptr, png_bytep row) png_write_row(png_structp png_ptr, png_bytep row)
{ {
@@ -766,49 +777,49 @@ png_write_row(png_structp png_ptr, png_bytep row)
png_debug2(1, "in png_write_row (row %ld, pass %d)", png_debug2(1, "in png_write_row (row %ld, pass %d)",
png_ptr->row_number, png_ptr->pass); png_ptr->row_number, png_ptr->pass);
/* initialize transformations and other stuff if first time */ /* Initialize transformations and other stuff if first time */
if (png_ptr->row_number == 0 && png_ptr->pass == 0) if (png_ptr->row_number == 0 && png_ptr->pass == 0)
{ {
/* make sure we wrote the header info */ /* Make sure we wrote the header info */
if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE)) if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
png_error(png_ptr, png_error(png_ptr,
"png_write_info was never called before png_write_row."); "png_write_info was never called before png_write_row.");
/* check for transforms that have been set but were defined out */ /* Check for transforms that have been set but were defined out */
#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED) #if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
if (png_ptr->transformations & PNG_INVERT_MONO) if (png_ptr->transformations & PNG_INVERT_MONO)
png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");
#endif #endif
#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED) #if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
if (png_ptr->transformations & PNG_FILLER) if (png_ptr->transformations & PNG_FILLER)
png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");
#endif #endif
#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED) #if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)
if (png_ptr->transformations & PNG_PACKSWAP) if (png_ptr->transformations & PNG_PACKSWAP)
png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");
#endif #endif
#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED) #if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
if (png_ptr->transformations & PNG_PACK) if (png_ptr->transformations & PNG_PACK)
png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");
#endif #endif
#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED) #if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
if (png_ptr->transformations & PNG_SHIFT) if (png_ptr->transformations & PNG_SHIFT)
png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");
#endif #endif
#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED) #if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
if (png_ptr->transformations & PNG_BGR) if (png_ptr->transformations & PNG_BGR)
png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");
#endif #endif
#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED) #if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
if (png_ptr->transformations & PNG_SWAP_BYTES) if (png_ptr->transformations & PNG_SWAP_BYTES)
png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined."); png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");
#endif #endif
png_write_start_row(png_ptr); png_write_start_row(png_ptr);
} }
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* if interlaced and not interested in row, return */ /* If interlaced and not interested in row, return */
if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE)) if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
{ {
switch (png_ptr->pass) switch (png_ptr->pass)
@@ -866,7 +877,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
} }
#endif #endif
/* set up row info for transformations */ /* Set up row info for transformations */
png_ptr->row_info.color_type = png_ptr->color_type; png_ptr->row_info.color_type = png_ptr->color_type;
png_ptr->row_info.width = png_ptr->usr_width; png_ptr->row_info.width = png_ptr->usr_width;
png_ptr->row_info.channels = png_ptr->usr_channels; png_ptr->row_info.channels = png_ptr->usr_channels;
@@ -889,13 +900,13 @@ png_write_row(png_structp png_ptr, png_bytep row)
png_ptr->row_info.rowbytes); png_ptr->row_info.rowbytes);
#if defined(PNG_WRITE_INTERLACING_SUPPORTED) #if defined(PNG_WRITE_INTERLACING_SUPPORTED)
/* handle interlacing */ /* Handle interlacing */
if (png_ptr->interlaced && png_ptr->pass < 6 && if (png_ptr->interlaced && png_ptr->pass < 6 &&
(png_ptr->transformations & PNG_INTERLACE)) (png_ptr->transformations & PNG_INTERLACE))
{ {
png_do_write_interlace(&(png_ptr->row_info), png_do_write_interlace(&(png_ptr->row_info),
png_ptr->row_buf + 1, png_ptr->pass); png_ptr->row_buf + 1, png_ptr->pass);
/* this should always get caught above, but still ... */ /* This should always get caught above, but still ... */
if (!(png_ptr->row_info.width)) if (!(png_ptr->row_info.width))
{ {
png_write_finish_row(png_ptr); png_write_finish_row(png_ptr);
@@ -904,7 +915,7 @@ png_write_row(png_structp png_ptr, png_bytep row)
} }
#endif #endif
/* handle other transformations */ /* Handle other transformations */
if (png_ptr->transformations) if (png_ptr->transformations)
png_do_write_transformations(png_ptr); png_do_write_transformations(png_ptr);
@@ -944,7 +955,7 @@ png_set_flush(png_structp png_ptr, int nrows)
png_ptr->flush_dist = (nrows < 0 ? 0 : nrows); png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
} }
/* flush the current output buffers now */ /* Flush the current output buffers now */
void PNGAPI void PNGAPI
png_write_flush(png_structp png_ptr) png_write_flush(png_structp png_ptr)
{ {
@@ -955,17 +966,17 @@ png_write_flush(png_structp png_ptr)
return; return;
/* We have already written out all of the data */ /* We have already written out all of the data */
if (png_ptr->row_number >= png_ptr->num_rows) if (png_ptr->row_number >= png_ptr->num_rows)
return; return;
do do
{ {
int ret; int ret;
/* compress the data */ /* Compress the data */
ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH); ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
wrote_IDAT = 0; wrote_IDAT = 0;
/* check for compression errors */ /* Check for compression errors */
if (ret != Z_OK) if (ret != Z_OK)
{ {
if (png_ptr->zstream.msg != NULL) if (png_ptr->zstream.msg != NULL)
@@ -976,7 +987,7 @@ png_write_flush(png_structp png_ptr)
if (!(png_ptr->zstream.avail_out)) if (!(png_ptr->zstream.avail_out))
{ {
/* write the IDAT and reset the zlib output buffer */ /* Write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf, png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size); png_ptr->zbuf_size);
png_ptr->zstream.next_out = png_ptr->zbuf; png_ptr->zstream.next_out = png_ptr->zbuf;
@@ -988,7 +999,7 @@ png_write_flush(png_structp png_ptr)
/* If there is any data left to be output, write it into a new IDAT */ /* If there is any data left to be output, write it into a new IDAT */
if (png_ptr->zbuf_size != png_ptr->zstream.avail_out) if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
{ {
/* write the IDAT and reset the zlib output buffer */ /* Write the IDAT and reset the zlib output buffer */
png_write_IDAT(png_ptr, png_ptr->zbuf, png_write_IDAT(png_ptr, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
png_ptr->zstream.next_out = png_ptr->zbuf; png_ptr->zstream.next_out = png_ptr->zbuf;
@@ -999,7 +1010,7 @@ png_write_flush(png_structp png_ptr)
} }
#endif /* PNG_WRITE_FLUSH_SUPPORTED */ #endif /* PNG_WRITE_FLUSH_SUPPORTED */
/* free all memory used by the write */ /* Free all memory used by the write */
void PNGAPI void PNGAPI
png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr) png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
{ {
@@ -1075,7 +1086,7 @@ void /* PRIVATE */
png_write_destroy(png_structp png_ptr) png_write_destroy(png_structp png_ptr)
{ {
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
jmp_buf tmp_jmp; /* save jump buffer */ jmp_buf tmp_jmp; /* Save jump buffer */
#endif #endif
png_error_ptr error_fn; png_error_ptr error_fn;
png_error_ptr warning_fn; png_error_ptr warning_fn;
@@ -1085,10 +1096,10 @@ png_write_destroy(png_structp png_ptr)
#endif #endif
png_debug(1, "in png_write_destroy"); png_debug(1, "in png_write_destroy");
/* free any memory zlib uses */ /* Free any memory zlib uses */
deflateEnd(&png_ptr->zstream); deflateEnd(&png_ptr->zstream);
/* free our memory. png_free checks NULL for us. */ /* Free our memory. png_free checks NULL for us. */
png_free(png_ptr, png_ptr->zbuf); png_free(png_ptr, png_ptr->zbuf);
png_free(png_ptr, png_ptr->row_buf); png_free(png_ptr, png_ptr->row_buf);
#ifndef PNG_NO_WRITE_FILTER #ifndef PNG_NO_WRITE_FILTER
@@ -1112,7 +1123,7 @@ png_write_destroy(png_structp png_ptr)
#endif #endif
#ifdef PNG_SETJMP_SUPPORTED #ifdef PNG_SETJMP_SUPPORTED
/* reset structure */ /* Reset structure */
png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf)); png_memcpy(tmp_jmp, png_ptr->jmpbuf, png_sizeof(jmp_buf));
#endif #endif
@@ -1415,7 +1426,7 @@ png_set_compression_window_bits(png_structp png_ptr, int window_bits)
else if (window_bits < 8) else if (window_bits < 8)
png_warning(png_ptr, "Only compression windows >= 256 supported by PNG"); png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
#ifndef WBITS_8_OK #ifndef WBITS_8_OK
/* avoid libpng bug with 256-byte windows */ /* Avoid libpng bug with 256-byte windows */
if (window_bits == 8) if (window_bits == 8)
{ {
png_warning(png_ptr, "Compression window is being reset to 512"); png_warning(png_ptr, "Compression window is being reset to 512");
@@ -1468,9 +1479,9 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) #if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
/* invert the alpha channel from opacity to transparency */ /* Invert the alpha channel from opacity to transparency */
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
png_set_invert_alpha(png_ptr); png_set_invert_alpha(png_ptr);
#endif #endif
/* Write the file header information. */ /* Write the file header information. */
@@ -1479,9 +1490,9 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
/* ------ these transformations don't touch the info structure ------- */ /* ------ these transformations don't touch the info structure ------- */
#if defined(PNG_WRITE_INVERT_SUPPORTED) #if defined(PNG_WRITE_INVERT_SUPPORTED)
/* invert monochrome pixels */ /* Invert monochrome pixels */
if (transforms & PNG_TRANSFORM_INVERT_MONO) if (transforms & PNG_TRANSFORM_INVERT_MONO)
png_set_invert_mono(png_ptr); png_set_invert_mono(png_ptr);
#endif #endif
#if defined(PNG_WRITE_SHIFT_SUPPORTED) #if defined(PNG_WRITE_SHIFT_SUPPORTED)
@@ -1490,57 +1501,57 @@ png_write_png(png_structp png_ptr, png_infop info_ptr,
*/ */
if ((transforms & PNG_TRANSFORM_SHIFT) if ((transforms & PNG_TRANSFORM_SHIFT)
&& (info_ptr->valid & PNG_INFO_sBIT)) && (info_ptr->valid & PNG_INFO_sBIT))
png_set_shift(png_ptr, &info_ptr->sig_bit); png_set_shift(png_ptr, &info_ptr->sig_bit);
#endif #endif
#if defined(PNG_WRITE_PACK_SUPPORTED) #if defined(PNG_WRITE_PACK_SUPPORTED)
/* pack pixels into bytes */ /* Pack pixels into bytes */
if (transforms & PNG_TRANSFORM_PACKING) if (transforms & PNG_TRANSFORM_PACKING)
png_set_packing(png_ptr); png_set_packing(png_ptr);
#endif #endif
#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) #if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
/* swap location of alpha bytes from ARGB to RGBA */ /* Swap location of alpha bytes from ARGB to RGBA */
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
#endif #endif
#if defined(PNG_WRITE_FILLER_SUPPORTED) #if defined(PNG_WRITE_FILLER_SUPPORTED)
/* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */ /* Pack XRGB/RGBX/ARGB/RGBA into * RGB (4 channels -> 3 channels) */
if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) if (transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER)
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) else if (transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE)
png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE); png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
#endif #endif
#if defined(PNG_WRITE_BGR_SUPPORTED) #if defined(PNG_WRITE_BGR_SUPPORTED)
/* flip BGR pixels to RGB */ /* Flip BGR pixels to RGB */
if (transforms & PNG_TRANSFORM_BGR) if (transforms & PNG_TRANSFORM_BGR)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
#endif #endif
#if defined(PNG_WRITE_SWAP_SUPPORTED) #if defined(PNG_WRITE_SWAP_SUPPORTED)
/* swap bytes of 16-bit files to most significant byte first */ /* Swap bytes of 16-bit files to most significant byte first */
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
png_set_swap(png_ptr); png_set_swap(png_ptr);
#endif #endif
#if defined(PNG_WRITE_PACKSWAP_SUPPORTED) #if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
/* swap bits of 1, 2, 4 bit packed pixel formats */ /* Swap bits of 1, 2, 4 bit packed pixel formats */
if (transforms & PNG_TRANSFORM_PACKSWAP) if (transforms & PNG_TRANSFORM_PACKSWAP)
png_set_packswap(png_ptr); png_set_packswap(png_ptr);
#endif #endif
/* ----------------------- end of transformations ------------------- */ /* ----------------------- end of transformations ------------------- */
/* write the bits */ /* Write the bits */
if (info_ptr->valid & PNG_INFO_IDAT) if (info_ptr->valid & PNG_INFO_IDAT)
png_write_image(png_ptr, info_ptr->row_pointers); png_write_image(png_ptr, info_ptr->row_pointers);
/* It is REQUIRED to call this to finish writing the rest of the file */ /* It is REQUIRED to call this to finish writing the rest of the file */
png_write_end(png_ptr, info_ptr); png_write_end(png_ptr, info_ptr);
transforms = transforms; /* quiet compiler warnings */ transforms = transforms; /* Quiet compiler warnings */
params = params; params = params;
} }
#endif #endif
src/libs/png/pngwtran.c
+8 -8
View File
@@ -1,9 +1,9 @@
/* pngwtran.c - transforms the data in a row for PNG writers /* pngwtran.c - transforms the data in a row for PNG writers
* *
* Last changed in libpng 1.2.9 April 14, 2006 * Last changed in libpng 1.2.37 [June 4, 2009]
* For conditions of distribution and use, see copyright notice in png.h * For conditions of distribution and use, see copyright notice in png.h
* Copyright (c) 1998-2006 Glenn Randers-Pehrson * Copyright (c) 1998-2009 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
*/ */
@@ -26,7 +26,7 @@ png_do_write_transformations(png_structp png_ptr)
#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) #if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
if (png_ptr->transformations & PNG_USER_TRANSFORM) if (png_ptr->transformations & PNG_USER_TRANSFORM)
if (png_ptr->write_user_transform_fn != NULL) if (png_ptr->write_user_transform_fn != NULL)
(*(png_ptr->write_user_transform_fn)) /* user write transform function */ (*(png_ptr->write_user_transform_fn)) /* User write transform function */
(png_ptr, /* png_ptr */ (png_ptr, /* png_ptr */
&(png_ptr->row_info), /* row_info: */ &(png_ptr->row_info), /* row_info: */
/* png_uint_32 width; width of row */ /* png_uint_32 width; width of row */
@@ -248,7 +248,7 @@ png_do_shift(png_row_infop row_info, png_bytep row, png_color_8p bit_depth)
channels++; channels++;
} }
/* with low row depths, could only be grayscale, so one channel */ /* With low row depths, could only be grayscale, so one channel */
if (row_info->bit_depth < 8) if (row_info->bit_depth < 8)
{ {
png_bytep bp = row; png_bytep bp = row;
@@ -439,7 +439,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
png_uint_32 row_width = row_info->width; png_uint_32 row_width = row_info->width;
for (i = 0, sp = dp = row; i < row_width; i++) for (i = 0, sp = dp = row; i < row_width; i++)
{ {
/* does nothing /* Does nothing
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
@@ -457,7 +457,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0, sp = dp = row; i < row_width; i++) for (i = 0, sp = dp = row; i < row_width; i++)
{ {
/* does nothing /* Does nothing
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
@@ -495,7 +495,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
for (i = 0, sp = dp = row; i < row_width; i++) for (i = 0, sp = dp = row; i < row_width; i++)
{ {
/* does nothing /* Does nothing
*(dp++) = *(sp++); *(dp++) = *(sp++);
*(dp++) = *(sp++); *(dp++) = *(sp++);
*/ */
@@ -510,7 +510,7 @@ png_do_write_invert_alpha(png_row_infop row_info, png_bytep row)
#endif #endif
#if defined(PNG_MNG_FEATURES_SUPPORTED) #if defined(PNG_MNG_FEATURES_SUPPORTED)
/* undoes intrapixel differencing */ /* Undoes intrapixel differencing */
void /* PRIVATE */ void /* PRIVATE */
png_do_write_intrapixel(png_row_infop row_info, png_bytep row) png_do_write_intrapixel(png_row_infop row_info, png_bytep row)
{ {
src/libs/png/pngwutil.c
+181 -178
View File
File diff suppressed because it is too large Load Diff