walkero
/
openjpeg
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Update to libpng 1.6.24 (#807)

This commit is contained in:
Matthieu Darbois 2016-08-06 12:51:40 +02:00 committed by GitHub
parent 5bb919a30e
commit 1509ccc51f
21 changed files with 1484 additions and 971 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
thirdparty/libpng/LICENSE vendored
View File

@ -10,7 +10,7 @@ this sentence.
This code is released under the libpng license. This code is released under the libpng license.
libpng versions 1.0.7, July 1, 2000, through 1.6.21, January 15, 2016, are libpng versions 1.0.7, July 1, 2000 through 1.6.24, August 4, 2016 are
Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are
derived from libpng-1.0.6, and are distributed according to the same derived from libpng-1.0.6, and are distributed according to the same
disclaimer and license as libpng-1.0.6 with the following individuals disclaimer and license as libpng-1.0.6 with the following individuals
@ -32,6 +32,10 @@ and with the following additions to the disclaimer:
risk of satisfactory quality, performance, accuracy, and effort is with risk of satisfactory quality, performance, accuracy, and effort is with
the user. the user.
Some files in the "contrib" directory and some configure-generated
files that are distributed with libpng have other copyright owners and
are released under other open source licenses.
libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
libpng-0.96, and are distributed according to the same disclaimer and libpng-0.96, and are distributed according to the same disclaimer and
@ -55,6 +59,9 @@ Contributing Authors:
Greg Roelofs Greg Roelofs
Tom Tanner Tom Tanner
Some files in the "scripts" directory have other copyright owners
but are released under this license.
libpng versions 0.5, May 1995, through 0.88, January 1996, are libpng versions 0.5, May 1995, through 0.88, January 1996, are
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
@ -95,18 +102,29 @@ appreciated.
END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE. END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
A "png_get_copyright" function is available, for convenient use in "about" TRADEMARK:
boxes and the like:
printf("%s", png_get_copyright(NULL)); The name "libpng" has not been registered by the Copyright owner
as a trademark in any jurisdiction. However, because libpng has
been distributed and maintained world-wide, continually since 1995,
the Copyright owner claims "common-law trademark protection" in any
jurisdiction where common-law trademark is recognized.
Also, the PNG logo (in PNG format, of course) is supplied in the OSI CERTIFICATION:
files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
Libpng is OSI Certified Open Source Software. OSI Certified Open Source is Libpng is OSI Certified Open Source Software. OSI Certified Open Source is
a certification mark of the Open Source Initiative. OSI has not addressed a certification mark of the Open Source Initiative. OSI has not addressed
the additional disclaimers inserted at version 1.0.7. the additional disclaimers inserted at version 1.0.7.
EXPORT CONTROL:
The Copyright owner believes that the Export Control Classification
Number (ECCN) for libpng is EAR99, which means not subject to export
controls or International Traffic in Arms Regulations (ITAR) because
it is open source, publicly available software, that does not contain
any encryption software. See the EAR, paragraphs 734.3(b)(3) and
734.7(b).
Glenn Randers-Pehrson Glenn Randers-Pehrson
glennrp at users.sourceforge.net glennrp at users.sourceforge.net
January 15, 2016 August 4, 2016

424
thirdparty/libpng/png.c vendored
View File

@ -1,7 +1,7 @@
/* png.c - location for general purpose libpng functions /* png.c - location for general purpose libpng functions
* *
* Last changed in libpng 1.6.19 [November 12, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2015 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.)
@ -14,7 +14,7 @@
#include "pngpriv.h" #include "pngpriv.h"
/* Generate a compiler error if there is an old png.h in the search path. */ /* Generate a compiler error if there is an old png.h in the search path. */
typedef png_libpng_version_1_6_21 Your_png_h_is_not_version_1_6_21; typedef png_libpng_version_1_6_24 Your_png_h_is_not_version_1_6_24;
/* Tells libpng that we have already handled the first "num_bytes" bytes /* Tells libpng that we have already handled the first "num_bytes" bytes
* of the PNG file signature. If the PNG data is embedded into another * of the PNG file signature. If the PNG data is embedded into another
@ -85,7 +85,7 @@ png_zalloc,(voidpf png_ptr, uInt items, uInt size),PNG_ALLOCATED)
if (items >= (~(png_alloc_size_t)0)/size) if (items >= (~(png_alloc_size_t)0)/size)
{ {
png_warning (png_voidcast(png_structrp, png_ptr), png_warning (png_voidcast(png_structrp, png_ptr),
"Potential overflow in png_zalloc()"); "Potential overflow in png_zalloc()");
return NULL; return NULL;
} }
@ -172,10 +172,10 @@ png_calculate_crc(png_structrp png_ptr, png_const_bytep ptr, png_size_t length)
int int
png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver) png_user_version_check(png_structrp png_ptr, png_const_charp user_png_ver)
{ {
/* Libpng versions 1.0.0 and later are binary compatible if the version /* Libpng versions 1.0.0 and later are binary compatible if the version
* string matches through the second '.'; we must recompile any * string matches through the second '.'; we must recompile any
* applications that use any older library version. * applications that use any older library version.
*/ */
if (user_png_ver != NULL) if (user_png_ver != NULL)
{ {
@ -297,7 +297,7 @@ png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
if (png_user_version_check(&create_struct, user_png_ver) != 0) if (png_user_version_check(&create_struct, user_png_ver) != 0)
{ {
png_structrp png_ptr = png_voidcast(png_structrp, png_structrp png_ptr = png_voidcast(png_structrp,
png_malloc_warn(&create_struct, (sizeof *png_ptr))); png_malloc_warn(&create_struct, (sizeof *png_ptr)));
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
@ -346,7 +346,7 @@ png_create_info_struct,(png_const_structrp png_ptr),PNG_ALLOCATED)
* has always been done in 'example.c'. * has always been done in 'example.c'.
*/ */
info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr, info_ptr = png_voidcast(png_inforp, png_malloc_base(png_ptr,
(sizeof *info_ptr))); (sizeof *info_ptr)));
if (info_ptr != NULL) if (info_ptr != NULL)
memset(info_ptr, 0, (sizeof *info_ptr)); memset(info_ptr, 0, (sizeof *info_ptr));
@ -402,7 +402,7 @@ png_destroy_info_struct(png_const_structrp png_ptr, png_infopp info_ptr_ptr)
*/ */
PNG_FUNCTION(void,PNGAPI PNG_FUNCTION(void,PNGAPI
png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size), png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
PNG_DEPRECATED) PNG_DEPRECATED)
{ {
png_inforp info_ptr = *ptr_ptr; png_inforp info_ptr = *ptr_ptr;
@ -417,7 +417,7 @@ png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
/* The following line is why this API should not be used: */ /* The following line is why this API should not be used: */
free(info_ptr); free(info_ptr);
info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL, info_ptr = png_voidcast(png_inforp, png_malloc_base(NULL,
(sizeof *info_ptr))); (sizeof *info_ptr)));
if (info_ptr == NULL) if (info_ptr == NULL)
return; return;
*ptr_ptr = info_ptr; *ptr_ptr = info_ptr;
@ -430,7 +430,7 @@ png_info_init_3,(png_infopp ptr_ptr, png_size_t png_info_struct_size),
/* The following API is not called internally */ /* The following API is not called internally */
void PNGAPI void PNGAPI
png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr, png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,
int freer, png_uint_32 mask) int freer, png_uint_32 mask)
{ {
png_debug(1, "in png_data_freer"); png_debug(1, "in png_data_freer");
@ -449,7 +449,7 @@ png_data_freer(png_const_structrp png_ptr, png_inforp info_ptr,
void PNGAPI void PNGAPI
png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask, png_free_data(png_const_structrp png_ptr, png_inforp info_ptr, png_uint_32 mask,
int num) int num)
{ {
png_debug(1, "in png_free_data"); png_debug(1, "in png_free_data");
@ -775,14 +775,14 @@ png_get_copyright(png_const_structrp png_ptr)
#else #else
# ifdef __STDC__ # ifdef __STDC__
return PNG_STRING_NEWLINE \ return PNG_STRING_NEWLINE \
"libpng version 1.6.21 - January 15, 2016" PNG_STRING_NEWLINE \ "libpng version 1.6.24 - August 4, 2016" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson" \ "Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson" \
PNG_STRING_NEWLINE \ PNG_STRING_NEWLINE \
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
PNG_STRING_NEWLINE; PNG_STRING_NEWLINE;
# else # else
return "libpng version 1.6.21 - January 15, 2016\ return "libpng version 1.6.24 - August 4, 2016\
Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson\ Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson\
Copyright (c) 1996-1997 Andreas Dilger\ Copyright (c) 1996-1997 Andreas Dilger\
Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc."; Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
@ -1033,7 +1033,7 @@ png_zstream_error(png_structrp png_ptr, int ret)
#ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */ #ifdef PNG_GAMMA_SUPPORTED /* always set if COLORSPACE */
static int static int
png_colorspace_check_gamma(png_const_structrp png_ptr, png_colorspace_check_gamma(png_const_structrp png_ptr,
png_colorspacerp colorspace, png_fixed_point gAMA, int from) png_colorspacerp colorspace, png_fixed_point gAMA, int from)
/* This is called to check a new gamma value against an existing one. The /* This is called to check a new gamma value against an existing one. The
* routine returns false if the new gamma value should not be written. * routine returns false if the new gamma value should not be written.
* *
@ -1047,7 +1047,7 @@ png_colorspace_check_gamma(png_const_structrp png_ptr,
png_fixed_point gtest; png_fixed_point gtest;
if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && if ((colorspace->flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
(png_muldiv(&gtest, colorspace->gamma, PNG_FP_1, gAMA) == 0 || (png_muldiv(&gtest, colorspace->gamma, PNG_FP_1, gAMA) == 0 ||
png_gamma_significant(gtest) != 0)) png_gamma_significant(gtest) != 0))
{ {
/* Either this is an sRGB image, in which case the calculated gamma /* Either this is an sRGB image, in which case the calculated gamma
@ -1059,7 +1059,7 @@ png_colorspace_check_gamma(png_const_structrp png_ptr,
if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2) if ((colorspace->flags & PNG_COLORSPACE_FROM_sRGB) != 0 || from == 2)
{ {
png_chunk_report(png_ptr, "gamma value does not match sRGB", png_chunk_report(png_ptr, "gamma value does not match sRGB",
PNG_CHUNK_ERROR); PNG_CHUNK_ERROR);
/* Do not overwrite an sRGB value */ /* Do not overwrite an sRGB value */
return from == 2; return from == 2;
} }
@ -1067,7 +1067,7 @@ png_colorspace_check_gamma(png_const_structrp png_ptr,
else /* sRGB tag not involved */ else /* sRGB tag not involved */
{ {
png_chunk_report(png_ptr, "gamma value does not match libpng estimate", png_chunk_report(png_ptr, "gamma value does not match libpng estimate",
PNG_CHUNK_WARNING); PNG_CHUNK_WARNING);
return from == 1; return from == 1;
} }
} }
@ -1077,7 +1077,7 @@ png_colorspace_check_gamma(png_const_structrp png_ptr,
void /* PRIVATE */ void /* PRIVATE */
png_colorspace_set_gamma(png_const_structrp png_ptr, png_colorspace_set_gamma(png_const_structrp png_ptr,
png_colorspacerp colorspace, png_fixed_point gAMA) png_colorspacerp colorspace, png_fixed_point gAMA)
{ {
/* Changed in libpng-1.5.4 to limit the values to ensure overflow can't /* Changed in libpng-1.5.4 to limit the values to ensure overflow can't
* occur. Since the fixed point representation is asymetrical it is * occur. Since the fixed point representation is asymetrical it is
@ -1635,8 +1635,8 @@ static const png_xy sRGB_xy = /* From ITU-R BT.709-3 */
static int static int
png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr, png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ, png_colorspacerp colorspace, const png_xy *xy, const png_XYZ *XYZ,
int preferred) int preferred)
{ {
if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0) if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
return 0; return 0;
@ -1683,7 +1683,7 @@ png_colorspace_set_xy_and_XYZ(png_const_structrp png_ptr,
int /* PRIVATE */ int /* PRIVATE */
png_colorspace_set_chromaticities(png_const_structrp png_ptr, png_colorspace_set_chromaticities(png_const_structrp png_ptr,
png_colorspacerp colorspace, const png_xy *xy, int preferred) png_colorspacerp colorspace, const png_xy *xy, int preferred)
{ {
/* We must check the end points to ensure they are reasonable - in the past /* We must check the end points to ensure they are reasonable - in the past
* color management systems have crashed as a result of getting bogus * color management systems have crashed as a result of getting bogus
@ -1697,7 +1697,7 @@ png_colorspace_set_chromaticities(png_const_structrp png_ptr,
{ {
case 0: /* success */ case 0: /* success */
return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ, return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, xy, &XYZ,
preferred); preferred);
case 1: case 1:
/* We can't invert the chromaticities so we can't produce value XYZ /* We can't invert the chromaticities so we can't produce value XYZ
@ -1720,7 +1720,7 @@ png_colorspace_set_chromaticities(png_const_structrp png_ptr,
int /* PRIVATE */ int /* PRIVATE */
png_colorspace_set_endpoints(png_const_structrp png_ptr, png_colorspace_set_endpoints(png_const_structrp png_ptr,
png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred) png_colorspacerp colorspace, const png_XYZ *XYZ_in, int preferred)
{ {
png_XYZ XYZ = *XYZ_in; png_XYZ XYZ = *XYZ_in;
png_xy xy; png_xy xy;
@ -1729,7 +1729,7 @@ png_colorspace_set_endpoints(png_const_structrp png_ptr,
{ {
case 0: case 0:
return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ, return png_colorspace_set_xy_and_XYZ(png_ptr, colorspace, &xy, &XYZ,
preferred); preferred);
case 1: case 1:
/* End points are invalid. */ /* End points are invalid. */
@ -1786,7 +1786,7 @@ is_ICC_signature(png_alloc_size_t it)
static int static int
png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace, png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
png_const_charp name, png_alloc_size_t value, png_const_charp reason) png_const_charp name, png_alloc_size_t value, png_const_charp reason)
{ {
size_t pos; size_t pos;
char message[196]; /* see below for calculation */ char message[196]; /* see below for calculation */
@ -1811,8 +1811,8 @@ png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/ char number[PNG_NUMBER_BUFFER_SIZE]; /* +24 = 114*/
pos = png_safecat(message, (sizeof message), pos, pos = png_safecat(message, (sizeof message), pos,
png_format_number(number, number+(sizeof number), png_format_number(number, number+(sizeof number),
PNG_NUMBER_FORMAT_x, value)); PNG_NUMBER_FORMAT_x, value));
pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/ pos = png_safecat(message, (sizeof message), pos, "h: "); /*+2 = 116*/
} }
# endif # endif
@ -1826,7 +1826,7 @@ png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
* application errors the PNG won't be written.) * application errors the PNG won't be written.)
*/ */
png_chunk_report(png_ptr, message, png_chunk_report(png_ptr, message,
(colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR); (colorspace != NULL) ? PNG_CHUNK_ERROR : PNG_CHUNK_WRITE_ERROR);
return 0; return 0;
} }
@ -1835,7 +1835,7 @@ png_icc_profile_error(png_const_structrp png_ptr, png_colorspacerp colorspace,
#ifdef PNG_sRGB_SUPPORTED #ifdef PNG_sRGB_SUPPORTED
int /* PRIVATE */ int /* PRIVATE */
png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace, png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
int intent) int intent)
{ {
/* sRGB sets known gamma, end points and (from the chunk) intent. */ /* sRGB sets known gamma, end points and (from the chunk) intent. */
/* IMPORTANT: these are not necessarily the values found in an ICC profile /* IMPORTANT: these are not necessarily the values found in an ICC profile
@ -1872,10 +1872,10 @@ png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
*/ */
if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST) if (intent < 0 || intent >= PNG_sRGB_INTENT_LAST)
return png_icc_profile_error(png_ptr, colorspace, "sRGB", return png_icc_profile_error(png_ptr, colorspace, "sRGB",
(unsigned)intent, "invalid sRGB rendering intent"); (unsigned)intent, "invalid sRGB rendering intent");
if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 && if ((colorspace->flags & PNG_COLORSPACE_HAVE_INTENT) != 0 &&
colorspace->rendering_intent != intent) colorspace->rendering_intent != intent)
return png_icc_profile_error(png_ptr, colorspace, "sRGB", return png_icc_profile_error(png_ptr, colorspace, "sRGB",
(unsigned)intent, "inconsistent rendering intents"); (unsigned)intent, "inconsistent rendering intents");
@ -1889,8 +1889,8 @@ png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
* warn but overwrite the value with the correct one. * warn but overwrite the value with the correct one.
*/ */
if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 && if ((colorspace->flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0 &&
!png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy, !png_colorspace_endpoints_match(&sRGB_xy, &colorspace->end_points_xy,
100)) 100))
png_chunk_report(png_ptr, "cHRM chunk does not match sRGB", png_chunk_report(png_ptr, "cHRM chunk does not match sRGB",
PNG_CHUNK_ERROR); PNG_CHUNK_ERROR);
@ -1898,7 +1898,7 @@ png_colorspace_set_sRGB(png_const_structrp png_ptr, png_colorspacerp colorspace,
* returns true when the 'from' argument corresponds to sRGB (2). * returns true when the 'from' argument corresponds to sRGB (2).
*/ */
(void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE, (void)png_colorspace_check_gamma(png_ptr, colorspace, PNG_GAMMA_sRGB_INVERSE,
2/*from sRGB*/); 2/*from sRGB*/);
/* intent: bugs in GCC force 'int' to be used as the parameter type. */ /* intent: bugs in GCC force 'int' to be used as the parameter type. */
colorspace->rendering_intent = (png_uint_16)intent; colorspace->rendering_intent = (png_uint_16)intent;
@ -1933,19 +1933,19 @@ static const png_byte D50_nCIEXYZ[12] =
int /* PRIVATE */ int /* PRIVATE */
png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace, png_icc_check_length(png_const_structrp png_ptr, png_colorspacerp colorspace,
png_const_charp name, png_uint_32 profile_length) png_const_charp name, png_uint_32 profile_length)
{ {
if (profile_length < 132) if (profile_length < 132)
return png_icc_profile_error(png_ptr, colorspace, name, profile_length, return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
"too short"); "too short");
return 1; return 1;
} }
int /* PRIVATE */ int /* PRIVATE */
png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace, png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
png_const_charp name, png_uint_32 profile_length, png_const_charp name, png_uint_32 profile_length,
png_const_bytep profile/* first 132 bytes only */, int color_type) png_const_bytep profile/* first 132 bytes only */, int color_type)
{ {
png_uint_32 temp; png_uint_32 temp;
@ -1957,18 +1957,18 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
temp = png_get_uint_32(profile); temp = png_get_uint_32(profile);
if (temp != profile_length) if (temp != profile_length)
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"length does not match profile"); "length does not match profile");
temp = (png_uint_32) (*(profile+8)); temp = (png_uint_32) (*(profile+8));
if (temp > 3 && (profile_length & 3)) if (temp > 3 && (profile_length & 3))
return png_icc_profile_error(png_ptr, colorspace, name, profile_length, return png_icc_profile_error(png_ptr, colorspace, name, profile_length,
"invalid length"); "invalid length");
temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */ temp = png_get_uint_32(profile+128); /* tag count: 12 bytes/tag */
if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */ if (temp > 357913930 || /* (2^32-4-132)/12: maximum possible tag count */
profile_length < 132+12*temp) /* truncated tag table */ profile_length < 132+12*temp) /* truncated tag table */
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"tag count too large"); "tag count too large");
/* The 'intent' must be valid or we can't store it, ICC limits the intent to /* The 'intent' must be valid or we can't store it, ICC limits the intent to
* 16 bits. * 16 bits.
@ -1976,14 +1976,14 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
temp = png_get_uint_32(profile+64); temp = png_get_uint_32(profile+64);
if (temp >= 0xffff) /* The ICC limit */ if (temp >= 0xffff) /* The ICC limit */
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"invalid rendering intent"); "invalid rendering intent");
/* This is just a warning because the profile may be valid in future /* This is just a warning because the profile may be valid in future
* versions. * versions.
*/ */
if (temp >= PNG_sRGB_INTENT_LAST) if (temp >= PNG_sRGB_INTENT_LAST)
(void)png_icc_profile_error(png_ptr, NULL, name, temp, (void)png_icc_profile_error(png_ptr, NULL, name, temp,
"intent outside defined range"); "intent outside defined range");
/* At this point the tag table can't be checked because it hasn't necessarily /* At this point the tag table can't be checked because it hasn't necessarily
* been loaded; however, various header fields can be checked. These checks * been loaded; however, various header fields can be checked. These checks
@ -2000,7 +2000,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
temp = png_get_uint_32(profile+36); /* signature 'ascp' */ temp = png_get_uint_32(profile+36); /* signature 'ascp' */
if (temp != 0x61637370) if (temp != 0x61637370)
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"invalid signature"); "invalid signature");
/* Currently the PCS illuminant/adopted white point (the computational /* Currently the PCS illuminant/adopted white point (the computational
* white point) are required to be D50, * white point) are required to be D50,
@ -2011,7 +2011,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
*/ */
if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0) if (memcmp(profile+68, D50_nCIEXYZ, 12) != 0)
(void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/, (void)png_icc_profile_error(png_ptr, NULL, name, 0/*no tag value*/,
"PCS illuminant is not D50"); "PCS illuminant is not D50");
/* The PNG spec requires this: /* The PNG spec requires this:
* "If the iCCP chunk is present, the image samples conform to the colour * "If the iCCP chunk is present, the image samples conform to the colour
@ -2039,18 +2039,18 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
case 0x52474220: /* 'RGB ' */ case 0x52474220: /* 'RGB ' */
if ((color_type & PNG_COLOR_MASK_COLOR) == 0) if ((color_type & PNG_COLOR_MASK_COLOR) == 0)
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"RGB color space not permitted on grayscale PNG"); "RGB color space not permitted on grayscale PNG");
break; break;
case 0x47524159: /* 'GRAY' */ case 0x47524159: /* 'GRAY' */
if ((color_type & PNG_COLOR_MASK_COLOR) != 0) if ((color_type & PNG_COLOR_MASK_COLOR) != 0)
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"Gray color space not permitted on RGB PNG"); "Gray color space not permitted on RGB PNG");
break; break;
default: default:
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"invalid ICC profile color space"); "invalid ICC profile color space");
} }
/* It is up to the application to check that the profile class matches the /* It is up to the application to check that the profile class matches the
@ -2075,7 +2075,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
case 0x61627374: /* 'abst' */ case 0x61627374: /* 'abst' */
/* May not be embedded in an image */ /* May not be embedded in an image */
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"invalid embedded Abstract ICC profile"); "invalid embedded Abstract ICC profile");
case 0x6c696e6b: /* 'link' */ case 0x6c696e6b: /* 'link' */
/* DeviceLink profiles cannot be interpreted in a non-device specific /* DeviceLink profiles cannot be interpreted in a non-device specific
@ -2085,7 +2085,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
* PNG. * PNG.
*/ */
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"unexpected DeviceLink ICC profile class"); "unexpected DeviceLink ICC profile class");
case 0x6e6d636c: /* 'nmcl' */ case 0x6e6d636c: /* 'nmcl' */
/* A NamedColor profile is also device specific, however it doesn't /* A NamedColor profile is also device specific, however it doesn't
@ -2093,7 +2093,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
* certainly it will fail the tests below. * certainly it will fail the tests below.
*/ */
(void)png_icc_profile_error(png_ptr, NULL, name, temp, (void)png_icc_profile_error(png_ptr, NULL, name, temp,
"unexpected NamedColor ICC profile class"); "unexpected NamedColor ICC profile class");
break; break;
default: default:
@ -2103,7 +2103,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
* understood profiles. * understood profiles.
*/ */
(void)png_icc_profile_error(png_ptr, NULL, name, temp, (void)png_icc_profile_error(png_ptr, NULL, name, temp,
"unrecognized ICC profile class"); "unrecognized ICC profile class");
break; break;
} }
@ -2119,7 +2119,7 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
default: default:
return png_icc_profile_error(png_ptr, colorspace, name, temp, return png_icc_profile_error(png_ptr, colorspace, name, temp,
"unexpected ICC PCS encoding"); "unexpected ICC PCS encoding");
} }
return 1; return 1;
@ -2127,8 +2127,8 @@ png_icc_check_header(png_const_structrp png_ptr, png_colorspacerp colorspace,
int /* PRIVATE */ int /* PRIVATE */
png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace, png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace,
png_const_charp name, png_uint_32 profile_length, png_const_charp name, png_uint_32 profile_length,
png_const_bytep profile /* header plus whole tag table */) png_const_bytep profile /* header plus whole tag table */)
{ {
png_uint_32 tag_count = png_get_uint_32(profile+128); png_uint_32 tag_count = png_get_uint_32(profile+128);
png_uint_32 itag; png_uint_32 itag;
@ -2156,7 +2156,7 @@ png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace,
* alignment. * alignment.
*/ */
(void)png_icc_profile_error(png_ptr, NULL, name, tag_id, (void)png_icc_profile_error(png_ptr, NULL, name, tag_id,
"ICC profile tag start not a multiple of 4"); "ICC profile tag start not a multiple of 4");
} }
/* This is a hard error; potentially it can cause read outside the /* This is a hard error; potentially it can cause read outside the
@ -2164,7 +2164,7 @@ png_icc_check_tag_table(png_const_structrp png_ptr, png_colorspacerp colorspace,
*/ */
if (tag_start > profile_length || tag_length > profile_length - tag_start) if (tag_start > profile_length || tag_length > profile_length - tag_start)
return png_icc_profile_error(png_ptr, colorspace, name, tag_id, return png_icc_profile_error(png_ptr, colorspace, name, tag_id,
"ICC profile tag outside profile"); "ICC profile tag outside profile");
} }
return 1; /* success, maybe with warnings */ return 1; /* success, maybe with warnings */
@ -2192,22 +2192,22 @@ static const struct
*/ */
/* adler32, crc32, MD5[4], intent, date, length, file-name */ /* adler32, crc32, MD5[4], intent, date, length, file-name */
PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9, PNG_ICC_CHECKSUM(0x0a3fd9f6, 0x3b8772b9,
PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0, PNG_MD5(0x29f83dde, 0xaff255ae, 0x7842fae4, 0xca83390d), 0, 0,
"2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc") "2009/03/27 21:36:31", 3048, "sRGB_IEC61966-2-1_black_scaled.icc")
/* ICC sRGB v2 perceptual no black-compensation: */ /* ICC sRGB v2 perceptual no black-compensation: */
PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21, PNG_ICC_CHECKSUM(0x4909e5e1, 0x427ebb21,
PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0, PNG_MD5(0xc95bd637, 0xe95d8a3b, 0x0df38f99, 0xc1320389), 1, 0,
"2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc") "2009/03/27 21:37:45", 3052, "sRGB_IEC61966-2-1_no_black_scaling.icc")
PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae, PNG_ICC_CHECKSUM(0xfd2144a1, 0x306fd8ae,
PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0, PNG_MD5(0xfc663378, 0x37e2886b, 0xfd72e983, 0x8228f1b8), 0, 0,
"2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc") "2009/08/10 17:28:01", 60988, "sRGB_v4_ICC_preference_displayclass.icc")
/* ICC sRGB v4 perceptual */ /* ICC sRGB v4 perceptual */
PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812, PNG_ICC_CHECKSUM(0x209c35d2, 0xbbef7812,
PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0, PNG_MD5(0x34562abf, 0x994ccd06, 0x6d2c5721, 0xd0d68c5d), 0, 0,
"2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc") "2007/07/25 00:05:37", 60960, "sRGB_v4_ICC_preference.icc")
/* The following profiles have no known MD5 checksum. If there is a match /* The following profiles have no known MD5 checksum. If there is a match
* on the (empty) MD5 the other fields are used to attempt a match and * on the (empty) MD5 the other fields are used to attempt a match and
@ -2215,8 +2215,8 @@ static const struct
* which suggests that they were also made by Hewlett Packard. * which suggests that they were also made by Hewlett Packard.
*/ */
PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce, PNG_ICC_CHECKSUM(0xa054d762, 0x5d5129ce,
PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0, PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 0,
"2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc") "2004/07/21 18:57:42", 3024, "sRGB_IEC61966-2-1_noBPC.icc")
/* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not /* This is a 'mntr' (display) profile with a mediaWhitePointTag that does not
* match the D50 PCS illuminant in the header (it is in fact the D65 values, * match the D50 PCS illuminant in the header (it is in fact the D65 values,
@ -2226,17 +2226,17 @@ static const struct
* chromaticAdaptationTag. * chromaticAdaptationTag.
*/ */
PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552, PNG_ICC_CHECKSUM(0xf784f3fb, 0x182ea552,
PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/, PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 0, 1/*broken*/,
"1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual") "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 perceptual")
PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d, PNG_ICC_CHECKSUM(0x0398f3fc, 0xf29e526d,
PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/, PNG_MD5(0x00000000, 0x00000000, 0x00000000, 0x00000000), 1, 1/*broken*/,
"1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative") "1998/02/09 06:49:00", 3144, "HP-Microsoft sRGB v2 media-relative")
}; };
static int static int
png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr, png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
png_const_bytep profile, uLong adler) png_const_bytep profile, uLong adler)
{ {
/* The quick check is to verify just the MD5 signature and trust the /* The quick check is to verify just the MD5 signature and trust the
* rest of the data. Because the profile has already been verified for * rest of the data. Because the profile has already been verified for
@ -2320,7 +2320,7 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
* which is made irrelevant by this error. * which is made irrelevant by this error.
*/ */
png_chunk_report(png_ptr, "known incorrect sRGB profile", png_chunk_report(png_ptr, "known incorrect sRGB profile",
PNG_CHUNK_ERROR); PNG_CHUNK_ERROR);
} }
/* Warn that this being done; this isn't even an error since /* Warn that this being done; this isn't even an error since
@ -2330,8 +2330,8 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
else if (png_sRGB_checks[i].have_md5 == 0) else if (png_sRGB_checks[i].have_md5 == 0)
{ {
png_chunk_report(png_ptr, png_chunk_report(png_ptr,
"out-of-date sRGB profile with no signature", "out-of-date sRGB profile with no signature",
PNG_CHUNK_WARNING); PNG_CHUNK_WARNING);
} }
return 1+png_sRGB_checks[i].is_broken; return 1+png_sRGB_checks[i].is_broken;
@ -2354,38 +2354,36 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
return 0; /* no match */ return 0; /* no match */
} }
#endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */
void /* PRIVATE */ void /* PRIVATE */
png_icc_set_sRGB(png_const_structrp png_ptr, png_icc_set_sRGB(png_const_structrp png_ptr,
png_colorspacerp colorspace, png_const_bytep profile, uLong adler) png_colorspacerp colorspace, png_const_bytep profile, uLong adler)
{ {
/* Is this profile one of the known ICC sRGB profiles? If it is, just set /* Is this profile one of the known ICC sRGB profiles? If it is, just set
* the sRGB information. * the sRGB information.
*/ */
#if PNG_sRGB_PROFILE_CHECKS >= 0
if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0) if (png_compare_ICC_profile_with_sRGB(png_ptr, profile, adler) != 0)
#endif
(void)png_colorspace_set_sRGB(png_ptr, colorspace, (void)png_colorspace_set_sRGB(png_ptr, colorspace,
(int)/*already checked*/png_get_uint_32(profile+64)); (int)/*already checked*/png_get_uint_32(profile+64));
} }
#endif /* PNG_sRGB_PROFILE_CHECKS >= 0 */
#endif /* sRGB */ #endif /* sRGB */
int /* PRIVATE */ int /* PRIVATE */
png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace, png_colorspace_set_ICC(png_const_structrp png_ptr, png_colorspacerp colorspace,
png_const_charp name, png_uint_32 profile_length, png_const_bytep profile, png_const_charp name, png_uint_32 profile_length, png_const_bytep profile,
int color_type) int color_type)
{ {
if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0) if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
return 0; return 0;
if (png_icc_check_length(png_ptr, colorspace, name, profile_length) != 0 && if (png_icc_check_length(png_ptr, colorspace, name, profile_length) != 0 &&
png_icc_check_header(png_ptr, colorspace, name, profile_length, profile, png_icc_check_header(png_ptr, colorspace, name, profile_length, profile,
color_type) != 0 && color_type) != 0 &&
png_icc_check_tag_table(png_ptr, colorspace, name, profile_length, png_icc_check_tag_table(png_ptr, colorspace, name, profile_length,
profile) != 0) profile) != 0)
{ {
# ifdef PNG_sRGB_SUPPORTED # if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0
/* If no sRGB support, don't try storing sRGB information */ /* If no sRGB support, don't try storing sRGB information */
png_icc_set_sRGB(png_ptr, colorspace, profile, 0); png_icc_set_sRGB(png_ptr, colorspace, profile, 0);
# endif # endif
@ -2444,7 +2442,7 @@ png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
/* Check for an internal error. */ /* Check for an internal error. */
if (r+g+b != 32768) if (r+g+b != 32768)
png_error(png_ptr, png_error(png_ptr,
"internal error handling cHRM coefficients"); "internal error handling cHRM coefficients");
else else
{ {
@ -2470,7 +2468,7 @@ png_colorspace_set_rgb_coefficients(png_structrp png_ptr)
static int /* PRIVATE */ static int /* PRIVATE */
png_gt(size_t a, size_t b) png_gt(size_t a, size_t b)
{ {
return a > b; return a > b;
} }
#else #else
# define png_gt(a,b) ((a) > (b)) # define png_gt(a,b) ((a) > (b))
@ -2478,9 +2476,9 @@ png_gt(size_t a, size_t b)
void /* PRIVATE */ void /* PRIVATE */
png_check_IHDR(png_const_structrp png_ptr, png_check_IHDR(png_const_structrp png_ptr,
png_uint_32 width, png_uint_32 height, int bit_depth, png_uint_32 width, png_uint_32 height, int bit_depth,
int color_type, int interlace_type, int compression_type, int color_type, int interlace_type, int compression_type,
int filter_type) int filter_type)
{ {
int error = 0; int error = 0;
@ -2643,7 +2641,7 @@ png_check_IHDR(png_const_structrp png_ptr,
int /* PRIVATE */ int /* PRIVATE */
png_check_fp_number(png_const_charp string, png_size_t size, int *statep, png_check_fp_number(png_const_charp string, png_size_t size, int *statep,
png_size_tp whereami) png_size_tp whereami)
{ {
int state = *statep; int state = *statep;
png_size_t i = *whereami; png_size_t i = *whereami;
@ -3806,25 +3804,25 @@ png_gamma_16bit_correct(unsigned int value, png_fixed_point gamma_val)
{ {
if (value > 0 && value < 65535) if (value > 0 && value < 65535)
{ {
# ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED # ifdef PNG_FLOATING_ARITHMETIC_SUPPORTED
/* The same (unsigned int)->(double) constraints apply here as above, /* The same (unsigned int)->(double) constraints apply here as above,
* however in this case the (unsigned int) to (int) conversion can * however in this case the (unsigned int) to (int) conversion can
* overflow on an ANSI-C90 compliant system so the cast needs to ensure * overflow on an ANSI-C90 compliant system so the cast needs to ensure
* that this is not possible. * that this is not possible.
*/ */
double r = floor(65535*pow((png_int_32)value/65535., double r = floor(65535*pow((png_int_32)value/65535.,
gamma_val*.00001)+.5); gamma_val*.00001)+.5);
return (png_uint_16)r; return (png_uint_16)r;
# else # else
png_int_32 lg2 = png_log16bit(value); png_int_32 lg2 = png_log16bit(value);
png_fixed_point res; png_fixed_point res;
if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0) if (png_muldiv(&res, gamma_val, lg2, PNG_FP_1) != 0)
return png_exp16bit(res); return png_exp16bit(res);
/* Overflow. */ /* Overflow. */
value = 0; value = 0;
# endif # endif
} }
return (png_uint_16)value; return (png_uint_16)value;
@ -3863,7 +3861,7 @@ png_gamma_correct(png_structrp png_ptr, unsigned int value,
*/ */
static void static void
png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable, png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
{ {
/* Various values derived from 'shift': */ /* Various values derived from 'shift': */
PNG_CONST unsigned int num = 1U << (8U - shift); PNG_CONST unsigned int num = 1U << (8U - shift);
@ -3940,7 +3938,7 @@ png_build_16bit_table(png_structrp png_ptr, png_uint_16pp *ptable,
*/ */
static void static void
png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable, png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val) PNG_CONST unsigned int shift, PNG_CONST png_fixed_point gamma_val)
{ {
PNG_CONST unsigned int num = 1U << (8U - shift); PNG_CONST unsigned int num = 1U << (8U - shift);
PNG_CONST unsigned int max = (1U << (16U - shift))-1U; PNG_CONST unsigned int max = (1U << (16U - shift))-1U;
@ -4008,7 +4006,7 @@ png_build_16to8_table(png_structrp png_ptr, png_uint_16pp *ptable,
*/ */
static void static void
png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable, png_build_8bit_table(png_structrp png_ptr, png_bytepp ptable,
PNG_CONST png_fixed_point gamma_val) PNG_CONST png_fixed_point gamma_val)
{ {
unsigned int i; unsigned int i;
png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256); png_bytep table = *ptable = (png_bytep)png_malloc(png_ptr, 256);
@ -4088,131 +4086,133 @@ png_destroy_gamma_table(png_structrp png_ptr)
void /* PRIVATE */ void /* PRIVATE */
png_build_gamma_table(png_structrp png_ptr, int bit_depth) png_build_gamma_table(png_structrp png_ptr, int bit_depth)
{ {
png_debug(1, "in png_build_gamma_table"); png_debug(1, "in png_build_gamma_table");
/* Remove any existing table; this copes with multiple calls to /* Remove any existing table; this copes with multiple calls to
* png_read_update_info. The warning is because building the gamma tables * png_read_update_info. The warning is because building the gamma tables
* multiple times is a performance hit - it's harmless but the ability to call * multiple times is a performance hit - it's harmless but the ability to
* png_read_update_info() multiple times is new in 1.5.6 so it seems sensible * call png_read_update_info() multiple times is new in 1.5.6 so it seems
* to warn if the app introduces such a hit. * sensible to warn if the app introduces such a hit.
*/ */
if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL) if (png_ptr->gamma_table != NULL || png_ptr->gamma_16_table != NULL)
{ {
png_warning(png_ptr, "gamma table being rebuilt"); png_warning(png_ptr, "gamma table being rebuilt");
png_destroy_gamma_table(png_ptr); png_destroy_gamma_table(png_ptr);
} }
if (bit_depth <= 8) if (bit_depth <= 8)
{ {
png_build_8bit_table(png_ptr, &png_ptr->gamma_table, png_build_8bit_table(png_ptr, &png_ptr->gamma_table,
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma, png_ptr->screen_gamma > 0 ?
png_ptr->screen_gamma) : PNG_FP_1); png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr->screen_gamma) : PNG_FP_1);
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0) if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
{ {
png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1, png_build_8bit_table(png_ptr, &png_ptr->gamma_to_1,
png_reciprocal(png_ptr->colorspace.gamma)); png_reciprocal(png_ptr->colorspace.gamma));
png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1, png_build_8bit_table(png_ptr, &png_ptr->gamma_from_1,
png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : png_ptr->screen_gamma > 0 ?
png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */); png_reciprocal(png_ptr->screen_gamma) :
} png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
}
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
} }
#ifdef PNG_16BIT_SUPPORTED #ifdef PNG_16BIT_SUPPORTED
else else
{ {
png_byte shift, sig_bit; png_byte shift, sig_bit;
if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
sig_bit = png_ptr->sig_bit.red; sig_bit = png_ptr->sig_bit.red;
if (png_ptr->sig_bit.green > sig_bit) if (png_ptr->sig_bit.green > sig_bit)
sig_bit = png_ptr->sig_bit.green; sig_bit = png_ptr->sig_bit.green;
if (png_ptr->sig_bit.blue > sig_bit) if (png_ptr->sig_bit.blue > sig_bit)
sig_bit = png_ptr->sig_bit.blue; sig_bit = png_ptr->sig_bit.blue;
} }
else else
sig_bit = png_ptr->sig_bit.gray; sig_bit = png_ptr->sig_bit.gray;
/* 16-bit gamma code uses this equation: /* 16-bit gamma code uses this equation:
* *
* ov = table[(iv & 0xff) >> gamma_shift][iv >> 8] * ov = table[(iv & 0xff) >> gamma_shift][iv >> 8]
* *
* Where 'iv' is the input color value and 'ov' is the output value - * Where 'iv' is the input color value and 'ov' is the output value -
* pow(iv, gamma). * pow(iv, gamma).
* *
* Thus the gamma table consists of up to 256 256-entry tables. The table * Thus the gamma table consists of up to 256 256-entry tables. The table
* is selected by the (8-gamma_shift) most significant of the low 8 bits of * is selected by the (8-gamma_shift) most significant of the low 8 bits
* the color value then indexed by the upper 8 bits: * of the color value then indexed by the upper 8 bits:
* *
* table[low bits][high 8 bits] * table[low bits][high 8 bits]
* *
* So the table 'n' corresponds to all those 'iv' of: * So the table 'n' corresponds to all those 'iv' of:
* *
* <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1> * <all high 8-bit values><n << gamma_shift>..<(n+1 << gamma_shift)-1>
* *
*/ */
if (sig_bit > 0 && sig_bit < 16U) if (sig_bit > 0 && sig_bit < 16U)
/* shift == insignificant bits */ /* shift == insignificant bits */
shift = (png_byte)((16U - sig_bit) & 0xff); shift = (png_byte)((16U - sig_bit) & 0xff);
else else
shift = 0; /* keep all 16 bits */ shift = 0; /* keep all 16 bits */
if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0) if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
{ {
/* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively /* PNG_MAX_GAMMA_8 is the number of bits to keep - effectively
* the significant bits in the *input* when the output will * the significant bits in the *input* when the output will
* eventually be 8 bits. By default it is 11. * eventually be 8 bits. By default it is 11.
*/ */
if (shift < (16U - PNG_MAX_GAMMA_8)) if (shift < (16U - PNG_MAX_GAMMA_8))
shift = (16U - PNG_MAX_GAMMA_8); shift = (16U - PNG_MAX_GAMMA_8);
} }
if (shift > 8U) if (shift > 8U)
shift = 8U; /* Guarantees at least one table! */ shift = 8U; /* Guarantees at least one table! */
png_ptr->gamma_shift = shift; png_ptr->gamma_shift = shift;
/* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now /* NOTE: prior to 1.5.4 this test used to include PNG_BACKGROUND (now
* PNG_COMPOSE). This effectively smashed the background calculation for * PNG_COMPOSE). This effectively smashed the background calculation for
* 16-bit output because the 8-bit table assumes the result will be reduced * 16-bit output because the 8-bit table assumes the result will be
* to 8 bits. * reduced to 8 bits.
*/ */
if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0) if ((png_ptr->transformations & (PNG_16_TO_8 | PNG_SCALE_16_TO_8)) != 0)
png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift, png_build_16to8_table(png_ptr, &png_ptr->gamma_16_table, shift,
png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma, png_ptr->screen_gamma > 0 ? png_product2(png_ptr->colorspace.gamma,
png_ptr->screen_gamma) : PNG_FP_1); png_ptr->screen_gamma) : PNG_FP_1);
else else
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift, png_build_16bit_table(png_ptr, &png_ptr->gamma_16_table, shift,
png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma, png_ptr->screen_gamma > 0 ? png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr->screen_gamma) : PNG_FP_1); png_ptr->screen_gamma) : PNG_FP_1);
#if defined(PNG_READ_BACKGROUND_SUPPORTED) || \ #if defined(PNG_READ_BACKGROUND_SUPPORTED) || \
defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \ defined(PNG_READ_ALPHA_MODE_SUPPORTED) || \
defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) defined(PNG_READ_RGB_TO_GRAY_SUPPORTED)
if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0) if ((png_ptr->transformations & (PNG_COMPOSE | PNG_RGB_TO_GRAY)) != 0)
{ {
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift, png_build_16bit_table(png_ptr, &png_ptr->gamma_16_to_1, shift,
png_reciprocal(png_ptr->colorspace.gamma)); png_reciprocal(png_ptr->colorspace.gamma));
/* Notice that the '16 from 1' table should be full precision, however /* Notice that the '16 from 1' table should be full precision, however
* the lookup on this table still uses gamma_shift, so it can't be. * the lookup on this table still uses gamma_shift, so it can't be.
* TODO: fix this. * TODO: fix this.
*/ */
png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift, png_build_16bit_table(png_ptr, &png_ptr->gamma_16_from_1, shift,
png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) : png_ptr->screen_gamma > 0 ? png_reciprocal(png_ptr->screen_gamma) :
png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */); png_ptr->colorspace.gamma/* Probably doing rgb_to_gray */);
} }
#endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */ #endif /* READ_BACKGROUND || READ_ALPHA_MODE || RGB_TO_GRAY */
} }
#endif /* 16BIT */ #endif /* 16BIT */
} }
#endif /* READ_GAMMA */ #endif /* READ_GAMMA */

370
thirdparty/libpng/png.h vendored
View File

@ -1,7 +1,7 @@
/* png.h - header file for PNG reference library /* png.h - header file for PNG reference library
* *
* libpng version 1.6.21, January 15, 2016 * libpng version 1.6.24, August 4, 2016
* *
* Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 Glenn Randers-Pehrson
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@ -12,7 +12,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.89, June 1996, through 0.96, May 1997: Andreas Dilger * libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
* libpng versions 0.97, January 1998, through 1.6.21, January 15, 2016: * libpng versions 0.97, January 1998, through 1.6.24, August 4, 2016:
* Glenn Randers-Pehrson. * Glenn Randers-Pehrson.
* See also "Contributing Authors", below. * See also "Contributing Authors", below.
*/ */
@ -25,7 +25,11 @@
* *
* This code is released under the libpng license. * This code is released under the libpng license.
* *
* libpng versions 1.0.7, July 1, 2000, through 1.6.21, January 15, 2016, are * Some files in the "contrib" directory and some configure-generated
* files that are distributed with libpng have other copyright owners and
* are released under other open source licenses.
*
* libpng versions 1.0.7, July 1, 2000 through 1.6.24, August 4, 2016 are
* Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are * Copyright (c) 2000-2002, 2004, 2006-2016 Glenn Randers-Pehrson, are
* derived from libpng-1.0.6, and are distributed according to the same * derived from libpng-1.0.6, and are distributed according to the same
* disclaimer and license as libpng-1.0.6 with the following individuals * disclaimer and license as libpng-1.0.6 with the following individuals
@ -47,6 +51,10 @@
* risk of satisfactory quality, performance, accuracy, and effort is with * risk of satisfactory quality, performance, accuracy, and effort is with
* the user. * the user.
* *
* Some files in the "contrib" directory have other copyright owners and
* are released under other open source licenses.
*
*
* libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are * libpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are
* Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from * Copyright (c) 1998-2000 Glenn Randers-Pehrson, are derived from
* libpng-0.96, and are distributed according to the same disclaimer and * libpng-0.96, and are distributed according to the same disclaimer and
@ -57,6 +65,9 @@
* Glenn Randers-Pehrson * Glenn Randers-Pehrson
* Willem van Schaik * Willem van Schaik
* *
* Some files in the "scripts" directory have different copyright owners
* but are also released under this license.
*
* libpng versions 0.89, June 1996, through 0.96, May 1997, are * libpng versions 0.89, June 1996, through 0.96, May 1997, are
* Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88, * Copyright (c) 1996-1997 Andreas Dilger, are derived from libpng-0.88,
* and are distributed according to the same disclaimer and license as * and are distributed according to the same disclaimer and license as
@ -70,6 +81,9 @@
* Greg Roelofs * Greg Roelofs
* Tom Tanner * Tom Tanner
* *
* Some files in the "scripts" directory have other copyright owners
* but are released under this license.
*
* libpng versions 0.5, May 1995, through 0.88, January 1996, are * libpng versions 0.5, May 1995, through 0.88, January 1996, are
* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.
* *
@ -109,6 +123,29 @@
* appreciated. * appreciated.
* *
* END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE. * END OF COPYRIGHT NOTICE, DISCLAIMER, and LICENSE.
*
* TRADEMARK:
*
* The name "libpng" has not been registered by the Copyright owner
* as a trademark in any jurisdiction. However, because libpng has
* been distributed and maintained world-wide, continually since 1995,
* the Copyright owner claims "common-law trademark protection" in any
* jurisdiction where common-law trademark is recognized.
*
* OSI CERTIFICATION:
*
* Libpng is OSI Certified Open Source Software. OSI Certified Open Source is
* a certification mark of the Open Source Initiative. OSI has not addressed
* the additional disclaimers inserted at version 1.0.7.
*
* EXPORT CONTROL:
*
* The Copyright owner believes that the Export Control Classification
* Number (ECCN) for libpng is EAR99, which means not subject to export
* controls or International Traffic in Arms Regulations (ITAR) because
* it is open source, publicly available software, that does not contain
* any encryption software. See the EAR, paragraphs 734.3(b)(3) and
* 734.7(b).
*/ */
/* /*
@ -121,12 +158,6 @@
* files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31). * files "pngbar.png" and "pngbar.jpg (88x31) and "pngnow.png" (98x31).
*/ */
/*
* Libpng is OSI Certified Open Source Software. OSI Certified Open Source is
* a certification mark of the Open Source Initiative. OSI has not addressed
* the additional disclaimers inserted at version 1.0.7.
*/
/* /*
* The contributing authors would like to thank all those who helped * The contributing authors would like to thank all those who helped
* with testing, bug fixes, and patience. This wouldn't have been * with testing, bug fixes, and patience. This wouldn't have been
@ -182,11 +213,11 @@
* ... * ...
* 1.0.19 10 10019 10.so.0.19[.0] * 1.0.19 10 10019 10.so.0.19[.0]
* ... * ...
* 1.2.53 13 10253 12.so.0.53[.0] * 1.2.56 13 10256 12.so.0.56[.0]
* ... * ...
* 1.5.23 15 10523 15.so.15.23[.0] * 1.5.27 15 10527 15.so.15.27[.0]
* ... * ...
* 1.6.21 16 10621 16.so.16.21[.0] * 1.6.24 16 10624 16.so.16.24[.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
@ -214,13 +245,13 @@
* Y2K compliance in libpng: * Y2K compliance in libpng:
* ========================= * =========================
* *
* January 15, 2016 * August 4, 2016
* *
* 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.6.21 are Y2K compliant. It is my belief that * upward through 1.6.24 are Y2K compliant. It is my belief that
* earlier versions were also Y2K compliant. * earlier versions were also Y2K compliant.
* *
* Libpng only has two year fields. One is a 2-byte unsigned integer * Libpng only has two year fields. One is a 2-byte unsigned integer
@ -282,9 +313,8 @@
*/ */
/* 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.6.21" #define PNG_LIBPNG_VER_STRING "1.6.24"
#define PNG_HEADER_VERSION_STRING \ #define PNG_HEADER_VERSION_STRING " libpng version 1.6.24 - August 4, 2016\n"
" libpng version 1.6.21 - January 15, 2016\n"
#define PNG_LIBPNG_VER_SONUM 16 #define PNG_LIBPNG_VER_SONUM 16
#define PNG_LIBPNG_VER_DLLNUM 16 #define PNG_LIBPNG_VER_DLLNUM 16
@ -292,7 +322,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 6 #define PNG_LIBPNG_VER_MINOR 6
#define PNG_LIBPNG_VER_RELEASE 21 #define PNG_LIBPNG_VER_RELEASE 24
/* 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:
@ -323,20 +353,20 @@
* 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 10621 /* 1.6.21 */ #define PNG_LIBPNG_VER 10624 /* 1.6.24 */
/* Library configuration: these options cannot be changed after /* Library configuration: these options cannot be changed after
* the library has been built. * the library has been built.
*/ */
#ifndef PNGLCONF_H #ifndef PNGLCONF_H
/* If pnglibconf.h is missing, you can /* If pnglibconf.h is missing, you can
* copy scripts/pnglibconf.h.prebuilt to pnglibconf.h * copy scripts/pnglibconf.h.prebuilt to pnglibconf.h
*/ */
# include "pnglibconf.h" # include "pnglibconf.h"
#endif #endif
#ifndef PNG_VERSION_INFO_ONLY #ifndef PNG_VERSION_INFO_ONLY
/* Machine specific configuration. */ /* Machine specific configuration. */
# include "pngconf.h" # include "pngconf.h"
#endif #endif
@ -433,7 +463,7 @@ extern "C" {
/* 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 char* png_libpng_version_1_6_21; typedef char* png_libpng_version_1_6_24;
/* Basic control structions. Read libpng-manual.txt or libpng.3 for more info. /* Basic control structions. Read libpng-manual.txt or libpng.3 for more info.
* *
@ -626,17 +656,17 @@ typedef png_time * * png_timepp;
*/ */
typedef struct png_unknown_chunk_t typedef struct png_unknown_chunk_t
{ {
png_byte name[5]; /* Textual chunk name with '\0' terminator */ png_byte name[5]; /* Textual chunk name with '\0' terminator */
png_byte *data; /* Data, should not be modified on read! */ png_byte *data; /* Data, should not be modified on read! */
png_size_t size; png_size_t size;
/* On write 'location' must be set using the flag values listed below. /* On write 'location' must be set using the flag values listed below.
* Notice that on read it is set by libpng however the values stored have * Notice that on read it is set by libpng however the values stored have
* more bits set than are listed below. Always treat the value as a * more bits set than are listed below. Always treat the value as a
* bitmask. On write set only one bit - setting multiple bits may cause the * bitmask. On write set only one bit - setting multiple bits may cause the
* chunk to be written in multiple places. * chunk to be written in multiple places.
*/ */
png_byte location; /* mode of operation at read time */ png_byte location; /* mode of operation at read time */
} }
png_unknown_chunk; png_unknown_chunk;
@ -734,24 +764,22 @@ typedef png_unknown_chunk * * png_unknown_chunkpp;
* data in the info_struct to be written into the output file. The values * data in the info_struct to be written into the output file. The values
* of the PNG_INFO_<chunk> defines should NOT be changed. * of the PNG_INFO_<chunk> defines should NOT be changed.
*/ */
#define PNG_INFO_gAMA 0x0001 #define PNG_INFO_gAMA 0x0001U
#define PNG_INFO_sBIT 0x0002 #define PNG_INFO_sBIT 0x0002U
#define PNG_INFO_cHRM 0x0004 #define PNG_INFO_cHRM 0x0004U
#define PNG_INFO_PLTE 0x0008 #define PNG_INFO_PLTE 0x0008U
#define PNG_INFO_tRNS 0x0010 #define PNG_INFO_tRNS 0x0010U
#define PNG_INFO_bKGD 0x0020 #define PNG_INFO_bKGD 0x0020U
#define PNG_INFO_hIST 0x0040 #define PNG_INFO_hIST 0x0040U
#define PNG_INFO_pHYs 0x0080 #define PNG_INFO_pHYs 0x0080U
#define PNG_INFO_oFFs 0x0100 #define PNG_INFO_oFFs 0x0100U
#define PNG_INFO_tIME 0x0200 #define PNG_INFO_tIME 0x0200U
#define PNG_INFO_pCAL 0x0400 #define PNG_INFO_pCAL 0x0400U
#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ #define PNG_INFO_sRGB 0x0800U /* GR-P, 0.96a */
#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ #define PNG_INFO_iCCP 0x1000U /* ESR, 1.0.6 */
#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ #define PNG_INFO_sPLT 0x2000U /* ESR, 1.0.6 */
#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ #define PNG_INFO_sCAL 0x4000U /* ESR, 1.0.6 */
#if INT_MAX >= 0x8000 /* else this might break */ #define PNG_INFO_IDAT 0x8000U /* ESR, 1.0.6 */
#define PNG_INFO_IDAT 0x8000 /* ESR, 1.0.6 */
#endif
/* This is used for the transformation routines, as some of them /* This is used for the transformation routines, as some of them
* change these values for the row. It also should enable using * change these values for the row. It also should enable using
@ -1322,7 +1350,7 @@ PNG_EXPORT(229, void, png_set_scale_16, (png_structrp png_ptr));
#endif #endif
#ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED #ifdef PNG_READ_STRIP_16_TO_8_SUPPORTED
#define PNG_READ_16_TO_8 SUPPORTED /* Name prior to 1.5.4 */ #define PNG_READ_16_TO_8_SUPPORTED /* Name prior to 1.5.4 */
/* Strip the second byte of information from a 16-bit depth file. */ /* Strip the second byte of information from a 16-bit depth file. */
PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr)); PNG_EXPORT(48, void, png_set_strip_16, (png_structrp png_ptr));
#endif #endif
@ -1473,8 +1501,8 @@ PNG_EXPORT(67, void, png_set_filter, (png_structrp png_ptr, int method,
#define PNG_FILTER_UP 0x20 #define PNG_FILTER_UP 0x20
#define PNG_FILTER_AVG 0x40 #define PNG_FILTER_AVG 0x40
#define PNG_FILTER_PAETH 0x80 #define PNG_FILTER_PAETH 0x80
#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ #define PNG_FAST_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP)
PNG_FILTER_AVG | PNG_FILTER_PAETH) #define PNG_ALL_FILTERS (PNG_FAST_FILTERS | PNG_FILTER_AVG | PNG_FILTER_PAETH)
/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. /* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now.
* These defines should NOT be changed. * These defines should NOT be changed.
@ -1751,21 +1779,21 @@ PNG_EXPORT(99, void, png_data_freer, (png_const_structrp png_ptr,
#define PNG_SET_WILL_FREE_DATA 1 #define PNG_SET_WILL_FREE_DATA 1
#define PNG_USER_WILL_FREE_DATA 2 #define PNG_USER_WILL_FREE_DATA 2
/* Flags for png_ptr->free_me and info_ptr->free_me */ /* Flags for png_ptr->free_me and info_ptr->free_me */
#define PNG_FREE_HIST 0x0008 #define PNG_FREE_HIST 0x0008U
#define PNG_FREE_ICCP 0x0010 #define PNG_FREE_ICCP 0x0010U
#define PNG_FREE_SPLT 0x0020 #define PNG_FREE_SPLT 0x0020U
#define PNG_FREE_ROWS 0x0040 #define PNG_FREE_ROWS 0x0040U
#define PNG_FREE_PCAL 0x0080 #define PNG_FREE_PCAL 0x0080U
#define PNG_FREE_SCAL 0x0100 #define PNG_FREE_SCAL 0x0100U
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
# define PNG_FREE_UNKN 0x0200 # define PNG_FREE_UNKN 0x0200U
#endif #endif
/* PNG_FREE_LIST 0x0400 removed in 1.6.0 because it is ignored */ /* PNG_FREE_LIST 0x0400U removed in 1.6.0 because it is ignored */
#define PNG_FREE_PLTE 0x1000 #define PNG_FREE_PLTE 0x1000U
#define PNG_FREE_TRNS 0x2000 #define PNG_FREE_TRNS 0x2000U
#define PNG_FREE_TEXT 0x4000 #define PNG_FREE_TEXT 0x4000U
#define PNG_FREE_ALL 0x7fff #define PNG_FREE_ALL 0x7fffU
#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ #define PNG_FREE_MUL 0x4220U /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr, PNG_EXPORTA(100, png_voidp, png_malloc_default, (png_const_structrp png_ptr,
@ -2271,8 +2299,10 @@ PNG_EXPORT(171, void, png_set_sCAL_s, (png_const_structrp png_ptr,
* except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to * except for the IHDR, PLTE, tRNS, IDAT, and IEND chunks (which continue to
* be processed by libpng. * be processed by libpng.
*/ */
#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr, PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
int keep, png_const_bytep chunk_list, int num_chunks)); int keep, png_const_bytep chunk_list, int num_chunks));
#endif /* HANDLE_AS_UNKNOWN */
/* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned; /* The "keep" PNG_HANDLE_CHUNK_ parameter for the specified chunk is returned;
* the result is therefore true (non-zero) if special handling is required, * the result is therefore true (non-zero) if special handling is required,
@ -2280,7 +2310,7 @@ PNG_EXPORT(172, void, png_set_keep_unknown_chunks, (png_structrp png_ptr,
*/ */
PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr, PNG_EXPORT(173, int, png_handle_as_unknown, (png_const_structrp png_ptr,
png_const_bytep chunk_name)); png_const_bytep chunk_name));
#endif #endif /* SET_UNKNOWN_CHUNKS */
#ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr, PNG_EXPORT(174, void, png_set_unknown_chunks, (png_const_structrp png_ptr,
@ -2501,33 +2531,37 @@ PNG_EXPORT(216, png_uint_32, png_get_io_chunk_type,
/* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */
# define png_composite(composite, fg, alpha, bg) \ # define png_composite(composite, fg, alpha, bg) \
{ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \ { \
* (png_uint_16)(alpha) \ png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) \
+ (png_uint_16)(bg)*(png_uint_16)(255 \ * (png_uint_16)(alpha) \
- (png_uint_16)(alpha)) + 128); \ + (png_uint_16)(bg)*(png_uint_16)(255 \
(composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); } - (png_uint_16)(alpha)) + 128); \
(composite) = (png_byte)(((temp + (temp >> 8)) >> 8) & 0xff); \
}
# define png_composite_16(composite, fg, alpha, bg) \ # define png_composite_16(composite, fg, alpha, bg) \
{ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \ { \
* (png_uint_32)(alpha) \ png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) \
+ (png_uint_32)(bg)*(65535 \ * (png_uint_32)(alpha) \
- (png_uint_32)(alpha)) + 32768); \ + (png_uint_32)(bg)*(65535 \
(composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); } - (png_uint_32)(alpha)) + 32768); \
(composite) = (png_uint_16)(0xffff & ((temp + (temp >> 16)) >> 16)); \
}
#else /* Standard method using integer division */ #else /* Standard method using integer division */
# define png_composite(composite, fg, alpha, bg) \ # define png_composite(composite, fg, alpha, bg) \
(composite) = \ (composite) = \
(png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) + \ (png_byte)(0xff & (((png_uint_16)(fg) * (png_uint_16)(alpha) + \
(png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \
127) / 255)) 127) / 255))
# define png_composite_16(composite, fg, alpha, bg) \ # define png_composite_16(composite, fg, alpha, bg) \
(composite) = \ (composite) = \
(png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \ (png_uint_16)(0xffff & (((png_uint_32)(fg) * (png_uint_32)(alpha) + \
(png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \ (png_uint_32)(bg)*(png_uint_32)(65535 - (png_uint_32)(alpha)) + \
32767) / 65535)) 32767) / 65535))
#endif /* READ_COMPOSITE_NODIV */ #endif /* READ_COMPOSITE_NODIV */
#ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
@ -2563,38 +2597,38 @@ PNG_EXPORT(207, void, png_save_uint_16, (png_bytep buf, unsigned int i));
* format for negative values, which is almost certainly true. * format for negative values, which is almost certainly true.
*/ */
# define PNG_get_uint_32(buf) \ # define PNG_get_uint_32(buf) \
(((png_uint_32)(*(buf)) << 24) + \ (((png_uint_32)(*(buf)) << 24) + \
((png_uint_32)(*((buf) + 1)) << 16) + \ ((png_uint_32)(*((buf) + 1)) << 16) + \
((png_uint_32)(*((buf) + 2)) << 8) + \ ((png_uint_32)(*((buf) + 2)) << 8) + \
((png_uint_32)(*((buf) + 3)))) ((png_uint_32)(*((buf) + 3))))
/* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the /* From libpng-1.4.0 until 1.4.4, the png_get_uint_16 macro (but not the
* function) incorrectly returned a value of type png_uint_32. * function) incorrectly returned a value of type png_uint_32.
*/ */
# define PNG_get_uint_16(buf) \ # define PNG_get_uint_16(buf) \
((png_uint_16) \ ((png_uint_16) \
(((unsigned int)(*(buf)) << 8) + \ (((unsigned int)(*(buf)) << 8) + \
((unsigned int)(*((buf) + 1))))) ((unsigned int)(*((buf) + 1)))))
# define PNG_get_int_32(buf) \ # define PNG_get_int_32(buf) \
((png_int_32)((*(buf) & 0x80) \ ((png_int_32)((*(buf) & 0x80) \
? -((png_int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \ ? -((png_int_32)(((png_get_uint_32(buf)^0xffffffffU)+1U)&0x7fffffffU)) \
: (png_int_32)png_get_uint_32(buf))) : (png_int_32)png_get_uint_32(buf)))
/* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h, /* If PNG_PREFIX is defined the same thing as below happens in pnglibconf.h,
* but defining a macro name prefixed with PNG_PREFIX. * but defining a macro name prefixed with PNG_PREFIX.
*/ */
# ifndef PNG_PREFIX # ifndef PNG_PREFIX
# define png_get_uint_32(buf) PNG_get_uint_32(buf) # define png_get_uint_32(buf) PNG_get_uint_32(buf)
# define png_get_uint_16(buf) PNG_get_uint_16(buf) # define png_get_uint_16(buf) PNG_get_uint_16(buf)
# define png_get_int_32(buf) PNG_get_int_32(buf) # define png_get_int_32(buf) PNG_get_int_32(buf)
# endif # endif
#else #else
# ifdef PNG_PREFIX # ifdef PNG_PREFIX
/* No macros; revert to the (redefined) function */ /* No macros; revert to the (redefined) function */
# define PNG_get_uint_32 (png_get_uint_32) # define PNG_get_uint_32 (png_get_uint_32)
# define PNG_get_uint_16 (png_get_uint_16) # define PNG_get_uint_16 (png_get_uint_16)
# define PNG_get_int_32 (png_get_int_32) # define PNG_get_int_32 (png_get_int_32)
# endif # endif
#endif #endif
@ -2889,12 +2923,19 @@ typedef struct
* is the minimum 'row stride', the minimum count of components between each * is the minimum 'row stride', the minimum count of components between each
* row. For a color-mapped image this is the minimum number of bytes in a * row. For a color-mapped image this is the minimum number of bytes in a
* row. * row.
*
* WARNING: this macro overflows for some images with more than one component
* and very large image widths. libpng will refuse to process an image where
* this macro would overflow.
*/ */
#define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\ #define PNG_IMAGE_BUFFER_SIZE(image, row_stride)\
(PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride)) (PNG_IMAGE_PIXEL_COMPONENT_SIZE((image).format)*(image).height*(row_stride))
/* Return the size, in bytes, of an image buffer given a png_image and a row /* Return the size, in bytes, of an image buffer given a png_image and a row
* stride - the number of components to leave space for in each row. * stride - the number of components to leave space for in each row.
*
* WARNING: this macro overflows a 32-bit integer for some large PNG images,
* libpng will refuse to process an image where such an overflow would occur.
*/ */
#define PNG_IMAGE_SIZE(image)\ #define PNG_IMAGE_SIZE(image)\
@ -3015,7 +3056,6 @@ PNG_EXPORT(238, void, png_image_free, (png_imagep image));
#endif /* SIMPLIFIED_READ */ #endif /* SIMPLIFIED_READ */
#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
#ifdef PNG_STDIO_SUPPORTED
/* WRITE APIS /* WRITE APIS
* ---------- * ----------
* For write you must initialize a png_image structure to describe the image to * For write you must initialize a png_image structure to describe the image to
@ -3032,6 +3072,7 @@ PNG_EXPORT(238, void, png_image_free, (png_imagep image));
* values do not correspond to the colors in sRGB. * values do not correspond to the colors in sRGB.
* colormap_entries: set to the number of entries in the color-map (0 to 256) * colormap_entries: set to the number of entries in the color-map (0 to 256)
*/ */
#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image, PNG_EXPORT(239, int, png_image_write_to_file, (png_imagep image,
const char *file, int convert_to_8bit, const void *buffer, const char *file, int convert_to_8bit, const void *buffer,
png_int_32 row_stride, const void *colormap)); png_int_32 row_stride, const void *colormap));
@ -3041,8 +3082,9 @@ PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
int convert_to_8_bit, const void *buffer, png_int_32 row_stride, int convert_to_8_bit, const void *buffer, png_int_32 row_stride,
const void *colormap)); const void *colormap));
/* Write the image to the given (FILE*). */ /* Write the image to the given (FILE*). */
#endif /* SIMPLIFIED_WRITE_STDIO */
/* With both write APIs if image is in one of the linear formats with 16-bit /* With all write APIs if image is in one of the linear formats with 16-bit
* data then setting convert_to_8_bit will cause the output to be an 8-bit PNG * data then setting convert_to_8_bit will cause the output to be an 8-bit PNG
* gamma encoded according to the sRGB specification, otherwise a 16-bit linear * gamma encoded according to the sRGB specification, otherwise a 16-bit linear
* encoded PNG file is written. * encoded PNG file is written.
@ -3054,13 +3096,103 @@ PNG_EXPORT(240, int, png_image_write_to_stdio, (png_imagep image, FILE *file,
* *
* With all APIs row_stride is handled as in the read APIs - it is the spacing * With all APIs row_stride is handled as in the read APIs - it is the spacing
* from one row to the next in component sized units (1 or 2 bytes) and if * from one row to the next in component sized units (1 or 2 bytes) and if
* negative indicates a bottom-up row layout in the buffer. If row_stride is zero, * negative indicates a bottom-up row layout in the buffer. If row_stride is
* libpng will calculate it for you from the image width and number of channels. * zero, libpng will calculate it for you from the image width and number of
* channels.
* *
* Note that the write API does not support interlacing, sub-8-bit pixels, indexed * Note that the write API does not support interlacing, sub-8-bit pixels or
* PNG (color_type 3) or most ancillary chunks. * most ancillary chunks. If you need to write text chunks (e.g. for copyright
* notices) you need to use one of the other APIs.
*/ */
#endif /* STDIO */
PNG_EXPORT(245, int, png_image_write_to_memory, (png_imagep image, void *memory,
png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8_bit,
const void *buffer, png_int_32 row_stride, const void *colormap));
/* Write the image to the given memory buffer. The function both writes the
* whole PNG data stream to *memory and updates *memory_bytes with the count
* of bytes written.
*
* 'memory' may be NULL. In this case *memory_bytes is not read however on
* success the number of bytes which would have been written will still be
* stored in *memory_bytes. On failure *memory_bytes will contain 0.
*
* If 'memory' is not NULL it must point to memory[*memory_bytes] of
* writeable memory.
*
* If the function returns success memory[*memory_bytes] (if 'memory' is not
* NULL) contains the written PNG data. *memory_bytes will always be less
* than or equal to the original value.
*
* If the function returns false and *memory_bytes was not changed an error
* occured during write. If *memory_bytes was changed, or is not 0 if
* 'memory' was NULL, the write would have succeeded but for the memory
* buffer being too small. *memory_bytes contains the required number of
* bytes and will be bigger that the original value.
*/
#define png_image_write_get_memory_size(image, size, convert_to_8_bit, buffer,\
row_stride, colormap)\
png_image_write_to_memory(&(image), 0, &(size), convert_to_8_bit, buffer,\
row_stride, colormap)
/* Return the amount of memory in 'size' required to compress this image.
* The png_image structure 'image' must be filled in as in the above
* function and must not be changed before the actual write call, the buffer
* and all other parameters must also be identical to that in the final
* write call. The 'size' variable need not be initialized.
*
* NOTE: the macro returns true/false, if false is returned 'size' will be
* set to zero and the write failed and probably will fail if tried again.
*/
/* You can pre-allocate the buffer by making sure it is of sufficient size
* regardless of the amount of compression achieved. The buffer size will
* always be bigger than the original image and it will never be filled. The
* following macros are provided to assist in allocating the buffer.
*/
#define PNG_IMAGE_DATA_SIZE(image) (PNG_IMAGE_SIZE(image)+(image).height)
/* The number of uncompressed bytes in the PNG byte encoding of the image;
* uncompressing the PNG IDAT data will give this number of bytes.
*
* NOTE: while PNG_IMAGE_SIZE cannot overflow for an image in memory this
* macro can because of the extra bytes used in the PNG byte encoding. You
* need to avoid this macro if your image size approaches 2^30 in width or
* height. The same goes for the remainder of these macros; they all produce
* bigger numbers than the actual in-memory image size.
*/
#ifndef PNG_ZLIB_MAX_SIZE
# define PNG_ZLIB_MAX_SIZE(b) ((b)+(((b)+7U)>>3)+(((b)+63U)>>6)+11U)
/* An upper bound on the number of compressed bytes given 'b' uncompressed
* bytes. This is based on deflateBounds() in zlib; different
* implementations of zlib compression may conceivably produce more data so
* if your zlib implementation is not zlib itself redefine this macro
* appropriately.
*/
#endif
#define PNG_IMAGE_COMPRESSED_SIZE_MAX(image)\
PNG_ZLIB_MAX_SIZE((png_alloc_size_t)PNG_IMAGE_DATA_SIZE(image))
/* An upper bound on the size of the data in the PNG IDAT chunks. */
#define PNG_IMAGE_PNG_SIZE_MAX_(image, image_size)\
((8U/*sig*/+25U/*IHDR*/+16U/*gAMA*/+44U/*cHRM*/+12U/*IEND*/+\
(((image).format&PNG_FORMAT_FLAG_COLORMAP)?/*colormap: PLTE, tRNS*/\
12U+3U*(image).colormap_entries/*PLTE data*/+\
(((image).format&PNG_FORMAT_FLAG_ALPHA)?\
12U/*tRNS*/+(image).colormap_entries:0U):0U)+\
12U)+(12U*((image_size)/PNG_ZBUF_SIZE))/*IDAT*/+(image_size))
/* A helper for the following macro; if your compiler cannot handle the
* following macro use this one with the result of
* PNG_IMAGE_COMPRESSED_SIZE_MAX(image) as the second argument (most
* compilers should handle this just fine.)
*/
#define PNG_IMAGE_PNG_SIZE_MAX(image)\
PNG_IMAGE_PNG_SIZE_MAX_(image, PNG_IMAGE_COMPRESSED_SIZE_MAX(image))
/* An upper bound on the total length of the PNG data stream for 'image'.
* The result is of type png_alloc_size_t, on 32-bit systems this may
* overflow even though PNG_IMAGE_DATA_SIZE does not overflow; the write will
* run out of buffer space but return a corrected size which should work.
*/
#endif /* SIMPLIFIED_WRITE */ #endif /* SIMPLIFIED_WRITE */
/******************************************************************************* /*******************************************************************************
* END OF SIMPLIFIED API * END OF SIMPLIFIED API
@ -3118,7 +3250,7 @@ PNG_EXPORT(244, int, png_set_option, (png_structrp png_ptr, int option,
* one to use is one more than this.) * one to use is one more than this.)
*/ */
#ifdef PNG_EXPORT_LAST_ORDINAL #ifdef PNG_EXPORT_LAST_ORDINAL
PNG_EXPORT_LAST_ORDINAL(244); PNG_EXPORT_LAST_ORDINAL(245);
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus

46
thirdparty/libpng/pngconf.h vendored
View File

@ -1,9 +1,9 @@
/* pngconf.h - machine configurable file for libpng /* pngconf.h - machine configurable file for libpng
* *
* libpng version 1.6.21, January 15, 2016 * libpng version 1.6.24, August 4, 2016
* *
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -188,27 +188,27 @@
* compatible with GCC or Visual C because of different calling conventions. * compatible with GCC or Visual C because of different calling conventions.
*/ */
# if PNG_API_RULE == 2 # if PNG_API_RULE == 2
/* If this line results in an error, either because __watcall is not /* If this line results in an error, either because __watcall is not
* understood or because of a redefine just below you cannot use *this* * understood or because of a redefine just below you cannot use *this*
* build of the library with the compiler you are using. *This* build was * build of the library with the compiler you are using. *This* build was
* build using Watcom and applications must also be built using Watcom! * build using Watcom and applications must also be built using Watcom!
*/ */
# define PNGCAPI __watcall # define PNGCAPI __watcall
# endif # endif
# if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800)) # if defined(__GNUC__) || (defined(_MSC_VER) && (_MSC_VER >= 800))
# define PNGCAPI __cdecl # define PNGCAPI __cdecl
# if PNG_API_RULE == 1 # if PNG_API_RULE == 1
/* If this line results in an error __stdcall is not understood and /* If this line results in an error __stdcall is not understood and
* PNG_API_RULE should not have been set to '1'. * PNG_API_RULE should not have been set to '1'.
*/ */
# define PNGAPI __stdcall # define PNGAPI __stdcall
# endif # endif
# else # else
/* An older compiler, or one not detected (erroneously) above, /* An older compiler, or one not detected (erroneously) above,
* if necessary override on the command line to get the correct * if necessary override on the command line to get the correct
* variants for the compiler. * variants for the compiler.
*/ */
# ifndef PNGCAPI # ifndef PNGCAPI
# define PNGCAPI _cdecl # define PNGCAPI _cdecl
# endif # endif
@ -225,10 +225,10 @@
# if (defined(_MSC_VER) && _MSC_VER < 800) ||\ # if (defined(_MSC_VER) && _MSC_VER < 800) ||\
(defined(__BORLANDC__) && __BORLANDC__ < 0x500) (defined(__BORLANDC__) && __BORLANDC__ < 0x500)
/* older Borland and MSC /* older Borland and MSC
* compilers used '__export' and required this to be after * compilers used '__export' and required this to be after
* the type. * the type.
*/ */
# ifndef PNG_EXPORT_TYPE # ifndef PNG_EXPORT_TYPE
# define PNG_EXPORT_TYPE(type) type PNG_IMPEXP # define PNG_EXPORT_TYPE(type) type PNG_IMPEXP
# endif # endif
@ -244,9 +244,9 @@
# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) # if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__)
# define PNGAPI _System # define PNGAPI _System
# else /* !Windows/x86 && !OS/2 */ # else /* !Windows/x86 && !OS/2 */
/* Use the defaults, or define PNG*API on the command line (but /* Use the defaults, or define PNG*API on the command line (but
* this will have to be done for every compile!) * this will have to be done for every compile!)
*/ */
# endif /* other system, !OS/2 */ # endif /* other system, !OS/2 */
#endif /* !Windows/x86 */ #endif /* !Windows/x86 */
@ -267,7 +267,7 @@
*/ */
#ifndef PNG_IMPEXP #ifndef PNG_IMPEXP
# if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT) # if defined(PNG_USE_DLL) && defined(PNG_DLL_IMPORT)
/* This forces use of a DLL, disallowing static linking */ /* This forces use of a DLL, disallowing static linking */
# define PNG_IMPEXP PNG_DLL_IMPORT # define PNG_IMPEXP PNG_DLL_IMPORT
# endif # endif
@ -340,7 +340,7 @@
* less efficient code. * less efficient code.
*/ */
# if defined(__clang__) && defined(__has_attribute) # if defined(__clang__) && defined(__has_attribute)
/* Clang defines both __clang__ and __GNUC__. Check __clang__ first. */ /* Clang defines both __clang__ and __GNUC__. Check __clang__ first. */
# if !defined(PNG_USE_RESULT) && __has_attribute(__warn_unused_result__) # if !defined(PNG_USE_RESULT) && __has_attribute(__warn_unused_result__)
# define PNG_USE_RESULT __attribute__((__warn_unused_result__)) # define PNG_USE_RESULT __attribute__((__warn_unused_result__))
# endif # endif

72
thirdparty/libpng/pngerror.c vendored
View File

@ -1,8 +1,8 @@
/* 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.6.15 [November 20, 2014] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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 @@ static PNG_FUNCTION(void, png_default_error,PNGARG((png_const_structrp png_ptr,
#ifdef PNG_WARNINGS_SUPPORTED #ifdef PNG_WARNINGS_SUPPORTED
static void /* PRIVATE */ static void /* PRIVATE */
png_default_warning PNGARG((png_const_structrp png_ptr, png_default_warning PNGARG((png_const_structrp png_ptr,
png_const_charp warning_message)); png_const_charp warning_message));
#endif /* WARNINGS */ #endif /* WARNINGS */
/* This function is called whenever there is a fatal error. This function /* This function is called whenever there is a fatal error. This function
@ -37,14 +37,14 @@ png_default_warning PNGARG((png_const_structrp png_ptr,
#ifdef PNG_ERROR_TEXT_SUPPORTED #ifdef PNG_ERROR_TEXT_SUPPORTED
PNG_FUNCTION(void,PNGAPI PNG_FUNCTION(void,PNGAPI
png_error,(png_const_structrp png_ptr, png_const_charp error_message), png_error,(png_const_structrp png_ptr, png_const_charp error_message),
PNG_NORETURN) PNG_NORETURN)
{ {
#ifdef PNG_ERROR_NUMBERS_SUPPORTED #ifdef PNG_ERROR_NUMBERS_SUPPORTED
char msg[16]; char msg[16];
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
if ((png_ptr->flags & if ((png_ptr->flags &
(PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0 (PNG_FLAG_STRIP_ERROR_NUMBERS|PNG_FLAG_STRIP_ERROR_TEXT)) != 0)
{ {
if (*error_message == PNG_LITERAL_SHARP) if (*error_message == PNG_LITERAL_SHARP)
{ {
@ -65,18 +65,18 @@ png_error,(png_const_structrp png_ptr, png_const_charp error_message),
else else
error_message += offset; error_message += offset;
}
else
{
if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
{
msg[0] = '0';
msg[1] = '\0';
error_message = msg;
} }
}
} else
{
if ((png_ptr->flags & PNG_FLAG_STRIP_ERROR_TEXT) != 0)
{
msg[0] = '0';
msg[1] = '\0';
error_message = msg;
}
}
}
} }
#endif #endif
if (png_ptr != NULL && png_ptr->error_fn != NULL) if (png_ptr != NULL && png_ptr->error_fn != NULL)
@ -110,7 +110,7 @@ png_err,(png_const_structrp png_ptr),PNG_NORETURN)
*/ */
size_t size_t
png_safecat(png_charp buffer, size_t bufsize, size_t pos, png_safecat(png_charp buffer, size_t bufsize, size_t pos,
png_const_charp string) png_const_charp string)
{ {
if (buffer != NULL && pos < bufsize) if (buffer != NULL && pos < bufsize)
{ {
@ -131,7 +131,7 @@ png_safecat(png_charp buffer, size_t bufsize, size_t pos,
*/ */
png_charp png_charp
png_format_number(png_const_charp start, png_charp end, int format, png_format_number(png_const_charp start, png_charp end, int format,
png_alloc_size_t number) png_alloc_size_t number)
{ {
int count = 0; /* number of digits output */ int count = 0; /* number of digits output */
int mincount = 1; /* minimum number required */ int mincount = 1; /* minimum number required */
@ -233,7 +233,7 @@ png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
} }
if (png_ptr != NULL && png_ptr->warning_fn != NULL) if (png_ptr != NULL && png_ptr->warning_fn != NULL)
(*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr), (*(png_ptr->warning_fn))(png_constcast(png_structrp,png_ptr),
warning_message + offset); warning_message + offset);
else else
png_default_warning(png_ptr, warning_message + offset); png_default_warning(png_ptr, warning_message + offset);
} }
@ -245,7 +245,7 @@ png_warning(png_const_structrp png_ptr, png_const_charp warning_message)
*/ */
void void
png_warning_parameter(png_warning_parameters p, int number, png_warning_parameter(png_warning_parameters p, int number,
png_const_charp string) png_const_charp string)
{ {
if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT) if (number > 0 && number <= PNG_WARNING_PARAMETER_COUNT)
(void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string); (void)png_safecat(p[number-1], (sizeof p[number-1]), 0, string);
@ -253,7 +253,7 @@ png_warning_parameter(png_warning_parameters p, int number,
void void
png_warning_parameter_unsigned(png_warning_parameters p, int number, int format, png_warning_parameter_unsigned(png_warning_parameters p, int number, int format,
png_alloc_size_t value) png_alloc_size_t value)
{ {
char buffer[PNG_NUMBER_BUFFER_SIZE]; char buffer[PNG_NUMBER_BUFFER_SIZE];
png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value)); png_warning_parameter(p, number, PNG_FORMAT_NUMBER(buffer, format, value));
@ -261,7 +261,7 @@ png_warning_parameter_unsigned(png_warning_parameters p, int number, int format,
void void
png_warning_parameter_signed(png_warning_parameters p, int number, int format, png_warning_parameter_signed(png_warning_parameters p, int number, int format,
png_int_32 value) png_int_32 value)
{ {
png_alloc_size_t u; png_alloc_size_t u;
png_charp str; png_charp str;
@ -282,7 +282,7 @@ png_warning_parameter_signed(png_warning_parameters p, int number, int format,
void void
png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p, png_formatted_warning(png_const_structrp png_ptr, png_warning_parameters p,
png_const_charp message) png_const_charp message)
{ {
/* The internal buffer is just 192 bytes - enough for all our messages, /* The internal buffer is just 192 bytes - enough for all our messages,
* overflow doesn't happen because this code checks! If someone figures * overflow doesn't happen because this code checks! If someone figures
@ -391,10 +391,10 @@ png_benign_error(png_const_structrp png_ptr, png_const_charp error_message)
void /* PRIVATE */ void /* PRIVATE */
png_app_warning(png_const_structrp png_ptr, png_const_charp error_message) png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
{ {
if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0) if ((png_ptr->flags & PNG_FLAG_APP_WARNINGS_WARN) != 0)
png_warning(png_ptr, error_message); png_warning(png_ptr, error_message);
else else
png_error(png_ptr, error_message); png_error(png_ptr, error_message);
# ifndef PNG_ERROR_TEXT_SUPPORTED # ifndef PNG_ERROR_TEXT_SUPPORTED
PNG_UNUSED(error_message) PNG_UNUSED(error_message)
@ -404,10 +404,10 @@ png_app_warning(png_const_structrp png_ptr, png_const_charp error_message)
void /* PRIVATE */ void /* PRIVATE */
png_app_error(png_const_structrp png_ptr, png_const_charp error_message) png_app_error(png_const_structrp png_ptr, png_const_charp error_message)
{ {
if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0) if ((png_ptr->flags & PNG_FLAG_APP_ERRORS_WARN) != 0)
png_warning(png_ptr, error_message); png_warning(png_ptr, error_message);
else else
png_error(png_ptr, error_message); png_error(png_ptr, error_message);
# ifndef PNG_ERROR_TEXT_SUPPORTED # ifndef PNG_ERROR_TEXT_SUPPORTED
PNG_UNUSED(error_message) PNG_UNUSED(error_message)
@ -478,7 +478,7 @@ png_format_buffer(png_const_structrp png_ptr, png_charp buffer, png_const_charp
#if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED) #if defined(PNG_READ_SUPPORTED) && defined(PNG_ERROR_TEXT_SUPPORTED)
PNG_FUNCTION(void,PNGAPI PNG_FUNCTION(void,PNGAPI
png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message), png_chunk_error,(png_const_structrp png_ptr, png_const_charp error_message),
PNG_NORETURN) PNG_NORETURN)
{ {
char msg[18+PNG_MAX_ERROR_TEXT]; char msg[18+PNG_MAX_ERROR_TEXT];
if (png_ptr == NULL) if (png_ptr == NULL)
@ -620,7 +620,7 @@ png_set_longjmp_fn(png_structrp png_ptr, png_longjmp_ptr longjmp_fn,
else else
{ {
png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *, png_ptr->jmp_buf_ptr = png_voidcast(jmp_buf *,
png_malloc_warn(png_ptr, jmp_buf_size)); png_malloc_warn(png_ptr, jmp_buf_size));
if (png_ptr->jmp_buf_ptr == NULL) if (png_ptr->jmp_buf_ptr == NULL)
return NULL; /* new NULL return on OOM */ return NULL; /* new NULL return on OOM */
@ -709,7 +709,7 @@ png_free_jmpbuf(png_structrp png_ptr)
*/ */
static PNG_FUNCTION(void /* PRIVATE */, static PNG_FUNCTION(void /* PRIVATE */,
png_default_error,(png_const_structrp png_ptr, png_const_charp error_message), png_default_error,(png_const_structrp png_ptr, png_const_charp error_message),
PNG_NORETURN) PNG_NORETURN)
{ {
#ifdef PNG_CONSOLE_IO_SUPPORTED #ifdef PNG_CONSOLE_IO_SUPPORTED
#ifdef PNG_ERROR_NUMBERS_SUPPORTED #ifdef PNG_ERROR_NUMBERS_SUPPORTED
@ -883,7 +883,7 @@ png_set_strip_error_numbers(png_structrp png_ptr, png_uint_32 strip_mode)
*/ */
PNG_FUNCTION(void /* PRIVATE */, (PNGCBAPI PNG_FUNCTION(void /* PRIVATE */, (PNGCBAPI
png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message), png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
PNG_NORETURN) PNG_NORETURN)
{ {
const png_const_structrp png_ptr = png_nonconst_ptr; const png_const_structrp png_ptr = png_nonconst_ptr;
png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr); png_imagep image = png_voidcast(png_imagep, png_ptr->error_ptr);
@ -906,7 +906,7 @@ png_safe_error),(png_structp png_nonconst_ptr, png_const_charp error_message),
/* Missing longjmp buffer, the following is to help debugging: */ /* Missing longjmp buffer, the following is to help debugging: */
{ {
size_t pos = png_safecat(image->message, (sizeof image->message), 0, size_t pos = png_safecat(image->message, (sizeof image->message), 0,
"bad longjmp: "); "bad longjmp: ");
png_safecat(image->message, (sizeof image->message), pos, png_safecat(image->message, (sizeof image->message), pos,
error_message); error_message);
} }

70
thirdparty/libpng/pngget.c vendored
View File

@ -1,8 +1,8 @@
/* pngget.c - retrieval of values from info struct /* pngget.c - retrieval of values from info struct
* *
* Last changed in libpng 1.6.17 [March 26, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -456,11 +456,11 @@ png_get_pHYs_dpi(png_const_structrp png_ptr, png_const_inforp info_ptr,
return (retval); return (retval);
} }
#endif /* pHYs */ #endif /* pHYs */
#endif /* INCH_CONVERSIONS */ #endif /* INCH_CONVERSIONS */
/* png_get_channels really belongs in here, too, but it's been around longer */ /* png_get_channels really belongs in here, too, but it's been around longer */
#endif /* EASY_ACCESS */ #endif /* EASY_ACCESS */
png_byte PNGAPI png_byte PNGAPI
@ -486,7 +486,7 @@ png_get_signature(png_const_structrp png_ptr, png_const_inforp info_ptr)
#ifdef PNG_bKGD_SUPPORTED #ifdef PNG_bKGD_SUPPORTED
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr, png_get_bKGD(png_const_structrp png_ptr, png_inforp info_ptr,
png_color_16p *background) png_color_16p *background)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->valid & PNG_INFO_bKGD) != 0 && (info_ptr->valid & PNG_INFO_bKGD) != 0 &&
@ -526,28 +526,28 @@ png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
if (white_x != NULL) if (white_x != NULL)
*white_x = png_float(png_ptr, *white_x = png_float(png_ptr,
info_ptr->colorspace.end_points_xy.whitex, "cHRM white X"); info_ptr->colorspace.end_points_xy.whitex, "cHRM white X");
if (white_y != NULL) if (white_y != NULL)
*white_y = png_float(png_ptr, *white_y = png_float(png_ptr,
info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y"); info_ptr->colorspace.end_points_xy.whitey, "cHRM white Y");
if (red_x != NULL) if (red_x != NULL)
*red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx, *red_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redx,
"cHRM red X"); "cHRM red X");
if (red_y != NULL) if (red_y != NULL)
*red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy, *red_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.redy,
"cHRM red Y"); "cHRM red Y");
if (green_x != NULL) if (green_x != NULL)
*green_x = png_float(png_ptr, *green_x = png_float(png_ptr,
info_ptr->colorspace.end_points_xy.greenx, "cHRM green X"); info_ptr->colorspace.end_points_xy.greenx, "cHRM green X");
if (green_y != NULL) if (green_y != NULL)
*green_y = png_float(png_ptr, *green_y = png_float(png_ptr,
info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y"); info_ptr->colorspace.end_points_xy.greeny, "cHRM green Y");
if (blue_x != NULL) if (blue_x != NULL)
*blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex, *blue_x = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluex,
"cHRM blue X"); "cHRM blue X");
if (blue_y != NULL) if (blue_y != NULL)
*blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey, *blue_y = png_float(png_ptr, info_ptr->colorspace.end_points_xy.bluey,
"cHRM blue Y"); "cHRM blue Y");
return (PNG_INFO_cHRM); return (PNG_INFO_cHRM);
} }
@ -556,42 +556,42 @@ png_get_cHRM(png_const_structrp png_ptr, png_const_inforp info_ptr,
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr, png_get_cHRM_XYZ(png_const_structrp png_ptr, png_const_inforp info_ptr,
double *red_X, double *red_Y, double *red_Z, double *green_X, double *red_X, double *red_Y, double *red_Z, double *green_X,
double *green_Y, double *green_Z, double *blue_X, double *blue_Y, double *green_Y, double *green_Z, double *blue_X, double *blue_Y,
double *blue_Z) double *blue_Z)
{ {
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
{ {
png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)"); png_debug1(1, "in %s retrieval function", "cHRM_XYZ(float)");
if (red_X != NULL) if (red_X != NULL)
*red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X, *red_X = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_X,
"cHRM red X"); "cHRM red X");
if (red_Y != NULL) if (red_Y != NULL)
*red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y, *red_Y = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Y,
"cHRM red Y"); "cHRM red Y");
if (red_Z != NULL) if (red_Z != NULL)
*red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z, *red_Z = png_float(png_ptr, info_ptr->colorspace.end_points_XYZ.red_Z,
"cHRM red Z"); "cHRM red Z");
if (green_X != NULL) if (green_X != NULL)
*green_X = png_float(png_ptr, *green_X = png_float(png_ptr,
info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X"); info_ptr->colorspace.end_points_XYZ.green_X, "cHRM green X");
if (green_Y != NULL) if (green_Y != NULL)
*green_Y = png_float(png_ptr, *green_Y = png_float(png_ptr,
info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y"); info_ptr->colorspace.end_points_XYZ.green_Y, "cHRM green Y");
if (green_Z != NULL) if (green_Z != NULL)
*green_Z = png_float(png_ptr, *green_Z = png_float(png_ptr,
info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z"); info_ptr->colorspace.end_points_XYZ.green_Z, "cHRM green Z");
if (blue_X != NULL) if (blue_X != NULL)
*blue_X = png_float(png_ptr, *blue_X = png_float(png_ptr,
info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X"); info_ptr->colorspace.end_points_XYZ.blue_X, "cHRM blue X");
if (blue_Y != NULL) if (blue_Y != NULL)
*blue_Y = png_float(png_ptr, *blue_Y = png_float(png_ptr,
info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y"); info_ptr->colorspace.end_points_XYZ.blue_Y, "cHRM blue Y");
if (blue_Z != NULL) if (blue_Z != NULL)
*blue_Z = png_float(png_ptr, *blue_Z = png_float(png_ptr,
info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z"); info_ptr->colorspace.end_points_XYZ.blue_Z, "cHRM blue Z");
return (PNG_INFO_cHRM); return (PNG_INFO_cHRM);
} }
@ -681,8 +681,8 @@ png_get_gAMA_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
png_debug1(1, "in %s retrieval function", "gAMA"); png_debug1(1, "in %s retrieval function", "gAMA");
if (png_ptr != NULL && info_ptr != NULL && if (png_ptr != NULL && info_ptr != NULL &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 && (info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0 &&
file_gamma != NULL) file_gamma != NULL)
{ {
*file_gamma = info_ptr->colorspace.gamma; *file_gamma = info_ptr->colorspace.gamma;
return (PNG_INFO_gAMA); return (PNG_INFO_gAMA);
@ -704,7 +704,7 @@ png_get_gAMA(png_const_structrp png_ptr, png_const_inforp info_ptr,
file_gamma != NULL) file_gamma != NULL)
{ {
*file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma, *file_gamma = png_float(png_ptr, info_ptr->colorspace.gamma,
"png_get_gAMA"); "png_get_gAMA");
return (PNG_INFO_gAMA); return (PNG_INFO_gAMA);
} }
@ -901,7 +901,7 @@ png_get_sCAL_fixed(png_const_structrp png_ptr, png_const_inforp info_ptr,
*/ */
*width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width"); *width = png_fixed(png_ptr, atof(info_ptr->scal_s_width), "sCAL width");
*height = png_fixed(png_ptr, atof(info_ptr->scal_s_height), *height = png_fixed(png_ptr, atof(info_ptr->scal_s_height),
"sCAL height"); "sCAL height");
return (PNG_INFO_sCAL); return (PNG_INFO_sCAL);
} }
@ -1142,19 +1142,19 @@ png_get_compression_buffer_size(png_const_structrp png_ptr)
return 0; return 0;
#ifdef PNG_WRITE_SUPPORTED #ifdef PNG_WRITE_SUPPORTED
if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
#endif #endif
{ {
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
return png_ptr->IDAT_read_size; return png_ptr->IDAT_read_size;
#else #else
return PNG_IDAT_READ_SIZE; return PNG_IDAT_READ_SIZE;
#endif #endif
} }
#ifdef PNG_WRITE_SUPPORTED #ifdef PNG_WRITE_SUPPORTED
else else
return png_ptr->zbuffer_size; return png_ptr->zbuffer_size;
#endif #endif
} }

5
thirdparty/libpng/pnglibconf.h vendored
View File

@ -1,8 +1,8 @@
/* libpng 1.6.21 STANDARD API DEFINITION */ /* libpng 1.6.24 STANDARD API DEFINITION */
/* pnglibconf.h - library build configuration */ /* pnglibconf.h - library build configuration */
/* Libpng version 1.6.21 - January 15, 2016 */ /* Libpng version 1.6.24 - August 4, 2016 */
/* Copyright (c) 1998-2015 Glenn Randers-Pehrson */ /* Copyright (c) 1998-2015 Glenn Randers-Pehrson */
@ -109,6 +109,7 @@
#define PNG_SIMPLIFIED_READ_SUPPORTED #define PNG_SIMPLIFIED_READ_SUPPORTED
#define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED #define PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
#define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED #define PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
#define PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
#define PNG_SIMPLIFIED_WRITE_SUPPORTED #define PNG_SIMPLIFIED_WRITE_SUPPORTED
#define PNG_STDIO_SUPPORTED #define PNG_STDIO_SUPPORTED
#define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED #define PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED

20
thirdparty/libpng/pngmem.c vendored
View File

@ -1,8 +1,8 @@
/* pngmem.c - stub functions for memory allocation /* pngmem.c - stub functions for memory allocation
* *
* Last changed in libpng 1.6.15 [November 20, 2014] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2014,2016 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.)
* *
@ -66,7 +66,7 @@ png_calloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
*/ */
PNG_FUNCTION(png_voidp /* PRIVATE */, PNG_FUNCTION(png_voidp /* PRIVATE */,
png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size), png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
PNG_ALLOCATED) PNG_ALLOCATED)
{ {
/* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS /* Moved to png_malloc_base from png_malloc_default in 1.6.0; the DOS
* allocators have also been removed in 1.6.0, so any 16-bit system now has * allocators have also been removed in 1.6.0, so any 16-bit system now has
@ -107,7 +107,7 @@ png_malloc_base,(png_const_structrp png_ptr, png_alloc_size_t size),
*/ */
static png_voidp static png_voidp
png_malloc_array_checked(png_const_structrp png_ptr, int nelements, png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
size_t element_size) size_t element_size)
{ {
png_alloc_size_t req = nelements; /* known to be > 0 */ png_alloc_size_t req = nelements; /* known to be > 0 */
@ -120,7 +120,7 @@ png_malloc_array_checked(png_const_structrp png_ptr, int nelements,
PNG_FUNCTION(png_voidp /* PRIVATE */, PNG_FUNCTION(png_voidp /* PRIVATE */,
png_malloc_array,(png_const_structrp png_ptr, int nelements, png_malloc_array,(png_const_structrp png_ptr, int nelements,
size_t element_size),PNG_ALLOCATED) size_t element_size),PNG_ALLOCATED)
{ {
if (nelements <= 0 || element_size == 0) if (nelements <= 0 || element_size == 0)
png_error(png_ptr, "internal error: array alloc"); png_error(png_ptr, "internal error: array alloc");
@ -130,7 +130,7 @@ png_malloc_array,(png_const_structrp png_ptr, int nelements,
PNG_FUNCTION(png_voidp /* PRIVATE */, PNG_FUNCTION(png_voidp /* PRIVATE */,
png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array, png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED) int old_elements, int add_elements, size_t element_size),PNG_ALLOCATED)
{ {
/* These are internal errors: */ /* These are internal errors: */
if (add_elements <= 0 || element_size == 0 || old_elements < 0 || if (add_elements <= 0 || element_size == 0 || old_elements < 0 ||
@ -143,7 +143,7 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
if (add_elements <= INT_MAX - old_elements) if (add_elements <= INT_MAX - old_elements)
{ {
png_voidp new_array = png_malloc_array_checked(png_ptr, png_voidp new_array = png_malloc_array_checked(png_ptr,
old_elements+add_elements, element_size); old_elements+add_elements, element_size);
if (new_array != NULL) if (new_array != NULL)
{ {
@ -154,7 +154,7 @@ png_realloc_array,(png_const_structrp png_ptr, png_const_voidp old_array,
memcpy(new_array, old_array, element_size*(unsigned)old_elements); memcpy(new_array, old_array, element_size*(unsigned)old_elements);
memset((char*)new_array + element_size*(unsigned)old_elements, 0, memset((char*)new_array + element_size*(unsigned)old_elements, 0,
element_size*(unsigned)add_elements); element_size*(unsigned)add_elements);
return new_array; return new_array;
} }
@ -187,7 +187,7 @@ png_malloc,(png_const_structrp png_ptr, png_alloc_size_t size),PNG_ALLOCATED)
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
PNG_FUNCTION(png_voidp,PNGAPI PNG_FUNCTION(png_voidp,PNGAPI
png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size), png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
PNG_ALLOCATED PNG_DEPRECATED) PNG_ALLOCATED PNG_DEPRECATED)
{ {
png_voidp ret; png_voidp ret;
@ -210,7 +210,7 @@ png_malloc_default,(png_const_structrp png_ptr, png_alloc_size_t size),
*/ */
PNG_FUNCTION(png_voidp,PNGAPI PNG_FUNCTION(png_voidp,PNGAPI
png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size), png_malloc_warn,(png_const_structrp png_ptr, png_alloc_size_t size),
PNG_ALLOCATED) PNG_ALLOCATED)
{ {
if (png_ptr != NULL) if (png_ptr != NULL)
{ {

39
thirdparty/libpng/pngpread.c vendored
View File

@ -1,8 +1,8 @@
/* pngpread.c - read a png file in push mode /* pngpread.c - read a png file in push mode
* *
* Last changed in libpng 1.6.18 [July 23, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -77,11 +77,11 @@ png_process_data_pause(png_structrp png_ptr, int save)
png_uint_32 PNGAPI png_uint_32 PNGAPI
png_process_data_skip(png_structrp png_ptr) png_process_data_skip(png_structrp png_ptr)
{ {
/* TODO: Deprecate and remove this API. /* TODO: Deprecate and remove this API.
* Somewhere the implementation of this seems to have been lost, * Somewhere the implementation of this seems to have been lost,
* or abandoned. It was only to support some internal back-door access * or abandoned. It was only to support some internal back-door access
* to png_struct) in libpng-1.4.x. * to png_struct) in libpng-1.4.x.
*/ */
png_app_warning(png_ptr, png_app_warning(png_ptr,
"png_process_data_skip is not implemented in any current version of libpng"); "png_process_data_skip is not implemented in any current version of libpng");
return 0; return 0;
@ -210,12 +210,14 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
(png_ptr->mode & PNG_HAVE_PLTE) == 0) (png_ptr->mode & PNG_HAVE_PLTE) == 0)
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
png_ptr->mode |= PNG_HAVE_IDAT;
png_ptr->process_mode = PNG_READ_IDAT_MODE; png_ptr->process_mode = PNG_READ_IDAT_MODE;
if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0) if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
if (png_ptr->push_length == 0) if ((png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) == 0)
return; if (png_ptr->push_length == 0)
return;
png_ptr->mode |= PNG_HAVE_IDAT;
if ((png_ptr->mode & PNG_AFTER_IDAT) != 0) if ((png_ptr->mode & PNG_AFTER_IDAT) != 0)
png_benign_error(png_ptr, "Too many IDATs found"); png_benign_error(png_ptr, "Too many IDATs found");
@ -408,7 +410,7 @@ png_push_read_chunk(png_structrp png_ptr, png_inforp info_ptr)
{ {
PNG_PUSH_SAVE_BUFFER_IF_FULL PNG_PUSH_SAVE_BUFFER_IF_FULL
png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length, png_handle_unknown(png_ptr, info_ptr, png_ptr->push_length,
PNG_HANDLE_CHUNK_AS_DEFAULT); PNG_HANDLE_CHUNK_AS_DEFAULT);
} }
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
@ -499,7 +501,10 @@ png_push_save_buffer(png_structrp png_ptr)
png_error(png_ptr, "Insufficient memory for save_buffer"); png_error(png_ptr, "Insufficient memory for save_buffer");
} }
memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); if (old_buffer)
memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
else if (png_ptr->save_buffer_size)
png_error(png_ptr, "save_buffer error");
png_free(png_ptr, old_buffer); png_free(png_ptr, old_buffer);
png_ptr->save_buffer_max = new_max; png_ptr->save_buffer_max = new_max;
} }
@ -516,7 +521,7 @@ png_push_save_buffer(png_structrp png_ptr)
void /* PRIVATE */ void /* PRIVATE */
png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer, png_push_restore_buffer(png_structrp png_ptr, png_bytep buffer,
png_size_t buffer_length) png_size_t buffer_length)
{ {
png_ptr->current_buffer = buffer; png_ptr->current_buffer = buffer;
png_ptr->current_buffer_size = buffer_length; png_ptr->current_buffer_size = buffer_length;
@ -619,7 +624,7 @@ png_push_read_IDAT(png_structrp png_ptr)
void /* PRIVATE */ void /* PRIVATE */
png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer, png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
png_size_t buffer_length) png_size_t buffer_length)
{ {
/* The caller checks for a non-zero buffer length. */ /* The caller checks for a non-zero buffer length. */
if (!(buffer_length > 0) || buffer == NULL) if (!(buffer_length > 0) || buffer == NULL)
@ -777,7 +782,7 @@ png_push_process_row(png_structrp png_ptr)
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
png_ptr->transformations); png_ptr->transformations);
switch (png_ptr->pass) switch (png_ptr->pass)
{ {
@ -1039,7 +1044,7 @@ png_push_have_row(png_structrp png_ptr, png_bytep row)
{ {
if (png_ptr->row_fn != NULL) if (png_ptr->row_fn != NULL)
(*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number, (*(png_ptr->row_fn))(png_ptr, row, png_ptr->row_number,
(int)png_ptr->pass); (int)png_ptr->pass);
} }
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED

34
thirdparty/libpng/pngpriv.h vendored
View File

@ -1,8 +1,8 @@
/* pngpriv.h - private declarations for use inside libpng /* pngpriv.h - private declarations for use inside libpng
* *
* Last changed in libpng 1.6.21 [January 15, 2016] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -420,10 +420,10 @@
# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ # if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \
defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC)
/* We need to check that <math.h> hasn't already been included earlier /* We need to check that <math.h> hasn't already been included earlier
* as it seems it doesn't agree with <fp.h>, yet we should really use * as it seems it doesn't agree with <fp.h>, yet we should really use
* <fp.h> if possible. * <fp.h> if possible.
*/ */
# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) # if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__)
# include <fp.h> # include <fp.h>
# endif # endif
@ -431,9 +431,9 @@
# include <math.h> # include <math.h>
# endif # endif
# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) # if defined(_AMIGA) && defined(__SASC) && defined(_M68881)
/* Amiga SAS/C: We must include builtin FPU functions when compiling using /* Amiga SAS/C: We must include builtin FPU functions when compiling using
* MATH=68881 * MATH=68881
*/ */
# include <m68881.h> # include <m68881.h>
# endif # endif
#endif #endif
@ -1025,7 +1025,7 @@ PNG_INTERNAL_FUNCTION(void,png_write_sBIT,(png_structrp png_ptr,
#ifdef PNG_WRITE_cHRM_SUPPORTED #ifdef PNG_WRITE_cHRM_SUPPORTED
PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_write_cHRM_fixed,(png_structrp png_ptr,
const png_xy *xy), PNG_EMPTY); const png_xy *xy), PNG_EMPTY);
/* The xy value must have been previously validated */ /* The xy value must have been previously validated */
#endif #endif
#ifdef PNG_WRITE_sRGB_SUPPORTED #ifdef PNG_WRITE_sRGB_SUPPORTED
@ -1174,6 +1174,7 @@ PNG_INTERNAL_FUNCTION(void,png_do_write_interlace,(png_row_infop row_info,
PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop PNG_INTERNAL_FUNCTION(void,png_read_filter_row,(png_structrp pp, png_row_infop
row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY); row_info, png_bytep row, png_const_bytep prev_row, int filter),PNG_EMPTY);
#if PNG_ARM_NEON_OPT > 0
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info, PNG_INTERNAL_FUNCTION(void,png_read_filter_row_up_neon,(png_row_infop row_info,
png_bytep row, png_const_bytep prev_row),PNG_EMPTY); png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop PNG_INTERNAL_FUNCTION(void,png_read_filter_row_sub3_neon,(png_row_infop
@ -1188,6 +1189,7 @@ PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth3_neon,(png_row_infop
row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop PNG_INTERNAL_FUNCTION(void,png_read_filter_row_paeth4_neon,(png_row_infop
row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY); row_info, png_bytep row, png_const_bytep prev_row),PNG_EMPTY);
#endif
/* Choose the best filter to use and filter the row data */ /* Choose the best filter to use and filter the row data */
PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_write_find_filter,(png_structrp png_ptr,
@ -1413,7 +1415,7 @@ PNG_INTERNAL_FUNCTION(void,png_push_have_info,(png_structrp png_ptr,
PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_push_have_end,(png_structrp png_ptr,
png_inforp info_ptr),PNG_EMPTY); png_inforp info_ptr),PNG_EMPTY);
PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_push_have_row,(png_structrp png_ptr,
png_bytep row),PNG_EMPTY); png_bytep row),PNG_EMPTY);
PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_push_read_end,(png_structrp png_ptr,
png_inforp info_ptr),PNG_EMPTY); png_inforp info_ptr),PNG_EMPTY);
PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_process_some_data,(png_structrp png_ptr,
@ -1452,13 +1454,13 @@ PNG_INTERNAL_FUNCTION(void,png_colorspace_set_gamma,(png_const_structrp png_ptr,
PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_colorspace_sync_info,(png_const_structrp png_ptr,
png_inforp info_ptr), PNG_EMPTY); png_inforp info_ptr), PNG_EMPTY);
/* Synchronize the info 'valid' flags with the colorspace */ /* Synchronize the info 'valid' flags with the colorspace */
PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr, PNG_INTERNAL_FUNCTION(void,png_colorspace_sync,(png_const_structrp png_ptr,
png_inforp info_ptr), PNG_EMPTY); png_inforp info_ptr), PNG_EMPTY);
/* Copy the png_struct colorspace to the info_struct and call the above to /* Copy the png_struct colorspace to the info_struct and call the above to
* synchronize the flags. Checks for NULL info_ptr and does nothing. * synchronize the flags. Checks for NULL info_ptr and does nothing.
*/ */
#endif #endif
/* Added at libpng version 1.4.0 */ /* Added at libpng version 1.4.0 */
@ -1913,8 +1915,10 @@ PNG_INTERNAL_FUNCTION(void, PNG_FILTER_OPTIMIZATIONS, (png_structp png_ptr,
* the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in * the builder of libpng passes the definition of PNG_FILTER_OPTIMIZATIONS in
* CFLAGS in place of CPPFLAGS *and* uses symbol prefixing. * CFLAGS in place of CPPFLAGS *and* uses symbol prefixing.
*/ */
# if PNG_ARM_NEON_OPT > 0
PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon, PNG_INTERNAL_FUNCTION(void, png_init_filter_functions_neon,
(png_structp png_ptr, unsigned int bpp), PNG_EMPTY); (png_structp png_ptr, unsigned int bpp), PNG_EMPTY);
# endif
#endif #endif
PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr, PNG_INTERNAL_FUNCTION(png_uint_32, png_check_keyword, (png_structrp png_ptr,

384
thirdparty/libpng/pngread.c vendored
View File

@ -1,8 +1,8 @@
/* pngread.c - read a PNG file /* pngread.c - read a PNG file
* *
* Last changed in libpng 1.6.17 [March 26, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -28,10 +28,10 @@ png_create_read_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
{ {
#ifndef PNG_USER_MEM_SUPPORTED #ifndef PNG_USER_MEM_SUPPORTED
png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr, png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
error_fn, warn_fn, NULL, NULL, NULL); error_fn, warn_fn, NULL, NULL, NULL);
#else #else
return png_create_read_struct_2(user_png_ver, error_ptr, error_fn, return png_create_read_struct_2(user_png_ver, error_ptr, error_fn,
warn_fn, NULL, NULL, NULL); warn_fn, NULL, NULL, NULL);
} }
/* Alternate create PNG structure for reading, and allocate any memory /* Alternate create PNG structure for reading, and allocate any memory
@ -43,7 +43,7 @@ png_create_read_struct_2,(png_const_charp user_png_ver, png_voidp error_ptr,
png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED) png_malloc_ptr malloc_fn, png_free_ptr free_fn),PNG_ALLOCATED)
{ {
png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr, png_structp png_ptr = png_create_png_struct(user_png_ver, error_ptr,
error_fn, warn_fn, mem_ptr, malloc_fn, free_fn); error_fn, warn_fn, mem_ptr, malloc_fn, free_fn);
#endif /* USER_MEM */ #endif /* USER_MEM */
if (png_ptr != NULL) if (png_ptr != NULL)
@ -127,7 +127,10 @@ png_read_info(png_structrp png_ptr, png_inforp info_ptr)
} }
else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0) else if ((png_ptr->mode & PNG_HAVE_IDAT) != 0)
{
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->mode |= PNG_AFTER_IDAT;
}
/* This should be a binary subdivision search or a hash for /* This should be a binary subdivision search or a hash for
* matching the chunk name rather than a linear search. * matching the chunk name rather than a linear search.
@ -249,7 +252,7 @@ png_read_info(png_structrp png_ptr, png_inforp info_ptr)
else else
png_handle_unknown(png_ptr, info_ptr, length, png_handle_unknown(png_ptr, info_ptr, length,
PNG_HANDLE_CHUNK_AS_DEFAULT); PNG_HANDLE_CHUNK_AS_DEFAULT);
} }
} }
#endif /* SEQUENTIAL_READ */ #endif /* SEQUENTIAL_READ */
@ -276,7 +279,7 @@ png_read_update_info(png_structrp png_ptr, png_inforp info_ptr)
/* New in 1.6.0 this avoids the bug of doing the initializations twice */ /* New in 1.6.0 this avoids the bug of doing the initializations twice */
else else
png_app_error(png_ptr, png_app_error(png_ptr,
"png_read_update_info/png_start_read_image: duplicate call"); "png_read_update_info/png_start_read_image: duplicate call");
} }
} }
@ -299,7 +302,7 @@ png_start_read_image(png_structrp png_ptr)
/* New in 1.6.0 this avoids the bug of doing the initializations twice */ /* New in 1.6.0 this avoids the bug of doing the initializations twice */
else else
png_app_error(png_ptr, png_app_error(png_ptr,
"png_start_read_image/png_read_update_info: duplicate call"); "png_start_read_image/png_read_update_info: duplicate call");
} }
} }
#endif /* SEQUENTIAL_READ */ #endif /* SEQUENTIAL_READ */
@ -537,7 +540,7 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
{ {
if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST) if (png_ptr->row_buf[0] < PNG_FILTER_VALUE_LAST)
png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1, png_read_filter_row(png_ptr, &row_info, png_ptr->row_buf + 1,
png_ptr->prev_row + 1, png_ptr->row_buf[0]); png_ptr->prev_row + 1, png_ptr->row_buf[0]);
else else
png_error(png_ptr, "bad adaptive filter value"); png_error(png_ptr, "bad adaptive filter value");
} }
@ -581,7 +584,7 @@ png_read_row(png_structrp png_ptr, png_bytep row, png_bytep dsp_row)
{ {
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass, png_do_read_interlace(&row_info, png_ptr->row_buf + 1, png_ptr->pass,
png_ptr->transformations); png_ptr->transformations);
if (dsp_row != NULL) if (dsp_row != NULL)
png_combine_row(png_ptr, dsp_row, 1/*display*/); png_combine_row(png_ptr, dsp_row, 1/*display*/);
@ -716,7 +719,7 @@ png_read_image(png_structrp png_ptr, png_bytepp image)
* but the caller should do it! * but the caller should do it!
*/ */
png_warning(png_ptr, "Interlace handling should be turned on when " png_warning(png_ptr, "Interlace handling should be turned on when "
"using png_read_image"); "using png_read_image");
/* Make sure this is set correctly */ /* Make sure this is set correctly */
png_ptr->num_rows = png_ptr->height; png_ptr->num_rows = png_ptr->height;
} }
@ -776,8 +779,8 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
#ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED #ifdef PNG_READ_CHECK_FOR_INVALID_INDEX_SUPPORTED
/* Report invalid palette index; added at libng-1.5.10 */ /* Report invalid palette index; added at libng-1.5.10 */
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
png_ptr->num_palette_max > png_ptr->num_palette) png_ptr->num_palette_max > png_ptr->num_palette)
png_benign_error(png_ptr, "Read palette index exceeding num_palette"); png_benign_error(png_ptr, "Read palette index exceeding num_palette");
#endif #endif
do do
@ -785,6 +788,9 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
png_uint_32 length = png_read_chunk_header(png_ptr); png_uint_32 length = png_read_chunk_header(png_ptr);
png_uint_32 chunk_name = png_ptr->chunk_name; png_uint_32 chunk_name = png_ptr->chunk_name;
if (chunk_name != png_IDAT)
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
if (chunk_name == png_IEND) if (chunk_name == png_IEND)
png_handle_IEND(png_ptr, info_ptr, length); png_handle_IEND(png_ptr, info_ptr, length);
@ -799,9 +805,9 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
{ {
if (chunk_name == png_IDAT) if (chunk_name == png_IDAT)
{ {
if ((length > 0) || if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
(png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
png_benign_error(png_ptr, "Too many IDATs found"); png_benign_error(png_ptr, ".Too many IDATs found");
} }
png_handle_unknown(png_ptr, info_ptr, length, keep); png_handle_unknown(png_ptr, info_ptr, length, keep);
if (chunk_name == png_PLTE) if (chunk_name == png_PLTE)
@ -812,10 +818,14 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
else if (chunk_name == png_IDAT) else if (chunk_name == png_IDAT)
{ {
/* Zero length IDATs are legal after the last IDAT has been /* Zero length IDATs are legal after the last IDAT has been
* read, but not after other chunks have been read. * read, but not after other chunks have been read. 1.6 does not
* always read all the deflate data; specifically it cannot be relied
* upon to read the Adler32 at the end. If it doesn't ignore IDAT
* chunks which are longer than zero as well:
*/ */
if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0) if ((length > 0 && !(png_ptr->flags & PNG_FLAG_ZSTREAM_ENDED))
png_benign_error(png_ptr, "Too many IDATs found"); || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT) != 0)
png_benign_error(png_ptr, "..Too many IDATs found");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
} }
@ -909,7 +919,7 @@ png_read_end(png_structrp png_ptr, png_inforp info_ptr)
else else
png_handle_unknown(png_ptr, info_ptr, length, png_handle_unknown(png_ptr, info_ptr, length,
PNG_HANDLE_CHUNK_AS_DEFAULT); PNG_HANDLE_CHUNK_AS_DEFAULT);
} while ((png_ptr->mode & PNG_HAVE_IEND) == 0); } while ((png_ptr->mode & PNG_HAVE_IEND) == 0);
} }
#endif /* SEQUENTIAL_READ */ #endif /* SEQUENTIAL_READ */
@ -1020,8 +1030,7 @@ png_set_read_status_fn(png_structrp png_ptr, png_read_status_ptr read_row_fn)
#ifdef PNG_INFO_IMAGE_SUPPORTED #ifdef PNG_INFO_IMAGE_SUPPORTED
void PNGAPI void PNGAPI
png_read_png(png_structrp png_ptr, png_inforp info_ptr, png_read_png(png_structrp png_ptr, png_inforp info_ptr,
int transforms, int transforms, voidp params)
voidp params)
{ {
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
@ -1297,7 +1306,7 @@ png_image_read_init(png_imagep image)
if (info_ptr != NULL) if (info_ptr != NULL)
{ {
png_controlp control = png_voidcast(png_controlp, png_controlp control = png_voidcast(png_controlp,
png_malloc_warn(png_ptr, (sizeof *control))); png_malloc_warn(png_ptr, (sizeof *control)));
if (control != NULL) if (control != NULL)
{ {
@ -1460,12 +1469,12 @@ png_image_begin_read_from_stdio(png_imagep image, FILE* file)
else else
return png_image_error(image, return png_image_error(image,
"png_image_begin_read_from_stdio: invalid argument"); "png_image_begin_read_from_stdio: invalid argument");
} }
else if (image != NULL) else if (image != NULL)
return png_image_error(image, return png_image_error(image,
"png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION"); "png_image_begin_read_from_stdio: incorrect PNG_IMAGE_VERSION");
return 0; return 0;
} }
@ -1498,12 +1507,12 @@ png_image_begin_read_from_file(png_imagep image, const char *file_name)
else else
return png_image_error(image, return png_image_error(image,
"png_image_begin_read_from_file: invalid argument"); "png_image_begin_read_from_file: invalid argument");
} }
else if (image != NULL) else if (image != NULL)
return png_image_error(image, return png_image_error(image,
"png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION"); "png_image_begin_read_from_file: incorrect PNG_IMAGE_VERSION");
return 0; return 0;
} }
@ -1540,7 +1549,7 @@ png_image_memory_read(png_structp png_ptr, png_bytep out, png_size_t need)
} }
int PNGAPI png_image_begin_read_from_memory(png_imagep image, int PNGAPI png_image_begin_read_from_memory(png_imagep image,
png_const_voidp memory, png_size_t size) png_const_voidp memory, png_size_t size)
{ {
if (image != NULL && image->version == PNG_IMAGE_VERSION) if (image != NULL && image->version == PNG_IMAGE_VERSION)
{ {
@ -1563,12 +1572,12 @@ int PNGAPI png_image_begin_read_from_memory(png_imagep image,
else else
return png_image_error(image, return png_image_error(image,
"png_image_begin_read_from_memory: invalid argument"); "png_image_begin_read_from_memory: invalid argument");
} }
else if (image != NULL) else if (image != NULL)
return png_image_error(image, return png_image_error(image,
"png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION"); "png_image_begin_read_from_memory: incorrect PNG_IMAGE_VERSION");
return 0; return 0;
} }
@ -1614,12 +1623,12 @@ png_image_skip_unused_chunks(png_structrp png_ptr)
* IHDR, PLTE, tRNS, IDAT, and IEND chunks. * IHDR, PLTE, tRNS, IDAT, and IEND chunks.
*/ */
png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER, png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_NEVER,
NULL, -1); NULL, -1);
/* But do not ignore image data handling chunks */ /* But do not ignore image data handling chunks */
png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT, png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_AS_DEFAULT,
chunks_to_process, (int)/*SAFE*/(sizeof chunks_to_process)/5); chunks_to_process, (int)/*SAFE*/(sizeof chunks_to_process)/5);
} }
} }
# define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p) # define PNG_SKIP_CHUNKS(p) png_image_skip_unused_chunks(p)
@ -1686,7 +1695,7 @@ decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding)
#ifdef __GNUC__ #ifdef __GNUC__
default: default:
png_error(display->image->opaque->png_ptr, png_error(display->image->opaque->png_ptr,
"unexpected encoding (internal error)"); "unexpected encoding (internal error)");
#endif #endif
} }
@ -1695,8 +1704,8 @@ decode_gamma(png_image_read_control *display, png_uint_32 value, int encoding)
static png_uint_32 static png_uint_32
png_colormap_compose(png_image_read_control *display, png_colormap_compose(png_image_read_control *display,
png_uint_32 foreground, int foreground_encoding, png_uint_32 alpha, png_uint_32 foreground, int foreground_encoding, png_uint_32 alpha,
png_uint_32 background, int encoding) png_uint_32 background, int encoding)
{ {
/* The file value is composed on the background, the background has the given /* The file value is composed on the background, the background has the given
* encoding and so does the result, the file is encoded with P_FILE and the * encoding and so does the result, the file is encoded with P_FILE and the
@ -1732,14 +1741,14 @@ png_colormap_compose(png_image_read_control *display,
*/ */
static void static void
png_create_colormap_entry(png_image_read_control *display, png_create_colormap_entry(png_image_read_control *display,
png_uint_32 ip, png_uint_32 red, png_uint_32 green, png_uint_32 blue, png_uint_32 ip, png_uint_32 red, png_uint_32 green, png_uint_32 blue,
png_uint_32 alpha, int encoding) png_uint_32 alpha, int encoding)
{ {
png_imagep image = display->image; png_imagep image = display->image;
const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ? const int output_encoding = (image->format & PNG_FORMAT_FLAG_LINEAR) != 0 ?
P_LINEAR : P_sRGB; P_LINEAR : P_sRGB;
const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 && const int convert_to_Y = (image->format & PNG_FORMAT_FLAG_COLOR) == 0 &&
(red != green || green != blue); (red != green || green != blue);
if (ip > 255) if (ip > 255)
png_error(image->opaque->png_ptr, "color-map index out of range"); png_error(image->opaque->png_ptr, "color-map index out of range");
@ -2019,7 +2028,7 @@ make_ga_colormap(png_image_read_control *display)
for (g=0; g<6; ++g) for (g=0; g<6; ++g)
png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51, png_create_colormap_entry(display, i++, g*51, g*51, g*51, a*51,
P_sRGB); P_sRGB);
} }
return i; return i;
@ -2043,7 +2052,7 @@ make_rgb_colormap(png_image_read_control *display)
for (b=0; b<6; ++b) for (b=0; b<6; ++b)
png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255, png_create_colormap_entry(display, i++, r*51, g*51, b*51, 255,
P_sRGB); P_sRGB);
} }
} }
@ -2095,7 +2104,7 @@ png_image_read_colormap(png_voidp argument)
else if (display->background == NULL /* no way to remove it */) else if (display->background == NULL /* no way to remove it */)
png_error(png_ptr, png_error(png_ptr,
"a background color must be supplied to remove alpha/transparency"); "background color must be supplied to remove alpha/transparency");
/* Get a copy of the background color (this avoids repeating the checks /* Get a copy of the background color (this avoids repeating the checks
* below.) The encoding is 8-bit sRGB or 16-bit linear, depending on the * below.) The encoding is 8-bit sRGB or 16-bit linear, depending on the
@ -2190,7 +2199,7 @@ png_image_read_colormap(png_voidp argument)
*/ */
if (i != trans) if (i != trans)
png_create_colormap_entry(display, i, val, val, val, 255, png_create_colormap_entry(display, i, val, val, val, 255,
P_FILE/*8-bit with file gamma*/); P_FILE/*8-bit with file gamma*/);
/* Else this entry is transparent. The colors don't matter if /* Else this entry is transparent. The colors don't matter if
* there is an alpha channel (back_alpha == 0), but it does no * there is an alpha channel (back_alpha == 0), but it does no
@ -2202,7 +2211,7 @@ png_image_read_colormap(png_voidp argument)
*/ */
else else
png_create_colormap_entry(display, i, back_r, back_g, back_b, png_create_colormap_entry(display, i, back_r, back_g, back_b,
back_alpha, output_encoding); back_alpha, output_encoding);
} }
/* We need libpng to preserve the original encoding. */ /* We need libpng to preserve the original encoding. */
@ -2267,7 +2276,7 @@ png_image_read_colormap(png_voidp argument)
* matches. * matches.
*/ */
png_create_colormap_entry(display, gray, back_g, back_g, png_create_colormap_entry(display, gray, back_g, back_g,
back_g, 65535, P_LINEAR); back_g, 65535, P_LINEAR);
} }
/* The background passed to libpng, however, must be the /* The background passed to libpng, however, must be the
@ -2281,8 +2290,8 @@ png_image_read_colormap(png_voidp argument)
* doesn't. * doesn't.
*/ */
png_set_background_fixed(png_ptr, &c, png_set_background_fixed(png_ptr, &c,
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
0/*gamma: not used*/); 0/*gamma: not used*/);
output_processing = PNG_CMAP_NONE; output_processing = PNG_CMAP_NONE;
break; break;
@ -2312,7 +2321,7 @@ png_image_read_colormap(png_voidp argument)
* background color at full precision. * background color at full precision.
*/ */
png_create_colormap_entry(display, 254, back_r, back_g, back_b, png_create_colormap_entry(display, 254, back_r, back_g, back_b,
back_alpha, output_encoding); back_alpha, output_encoding);
} }
else else
@ -2380,7 +2389,7 @@ png_image_read_colormap(png_voidp argument)
/* And make sure the corresponding palette entry matches. */ /* And make sure the corresponding palette entry matches. */
png_create_colormap_entry(display, gray, back_g, back_g, png_create_colormap_entry(display, gray, back_g, back_g,
back_g, 65535, P_LINEAR); back_g, 65535, P_LINEAR);
} }
/* The background passed to libpng, however, must be the sRGB /* The background passed to libpng, however, must be the sRGB
@ -2390,8 +2399,8 @@ png_image_read_colormap(png_voidp argument)
c.gray = c.red = c.green = c.blue = (png_uint_16)gray; c.gray = c.red = c.green = c.blue = (png_uint_16)gray;
png_set_background_fixed(png_ptr, &c, png_set_background_fixed(png_ptr, &c,
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
0/*gamma: not used*/); 0/*gamma: not used*/);
output_processing = PNG_CMAP_NONE; output_processing = PNG_CMAP_NONE;
} }
@ -2411,7 +2420,7 @@ png_image_read_colormap(png_voidp argument)
{ {
png_uint_32 gray = (i * 256 + 115) / 231; png_uint_32 gray = (i * 256 + 115) / 231;
png_create_colormap_entry(display, i++, gray, gray, gray, png_create_colormap_entry(display, i++, gray, gray, gray,
255, P_sRGB); 255, P_sRGB);
} }
/* NOTE: this preserves the full precision of the application /* NOTE: this preserves the full precision of the application
@ -2420,13 +2429,13 @@ png_image_read_colormap(png_voidp argument)
background_index = i; background_index = i;
png_create_colormap_entry(display, i++, back_r, back_g, back_b, png_create_colormap_entry(display, i++, back_r, back_g, back_b,
#ifdef __COVERITY__ #ifdef __COVERITY__
/* Coverity claims that output_encoding cannot be 2 (P_LINEAR) /* Coverity claims that output_encoding
* here. * cannot be 2 (P_LINEAR) here.
*/ 255U, */ 255U,
#else #else
output_encoding == P_LINEAR ? 65535U : 255U, output_encoding == P_LINEAR ? 65535U : 255U,
#endif #endif
output_encoding); output_encoding);
/* For non-opaque input composite on the sRGB background - this /* For non-opaque input composite on the sRGB background - this
* requires inverting the encoding for each component. The input * requires inverting the encoding for each component. The input
@ -2464,9 +2473,9 @@ png_image_read_colormap(png_voidp argument)
png_uint_32 gray = png_sRGB_table[g*51] * alpha; png_uint_32 gray = png_sRGB_table[g*51] * alpha;
png_create_colormap_entry(display, i++, png_create_colormap_entry(display, i++,
PNG_sRGB_FROM_LINEAR(gray + back_rx), PNG_sRGB_FROM_LINEAR(gray + back_rx),
PNG_sRGB_FROM_LINEAR(gray + back_gx), PNG_sRGB_FROM_LINEAR(gray + back_gx),
PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, P_sRGB); PNG_sRGB_FROM_LINEAR(gray + back_bx), 255, P_sRGB);
} }
} }
@ -2492,7 +2501,7 @@ png_image_read_colormap(png_voidp argument)
* png_set_tRNS_to_alpha before png_set_background_fixed. * png_set_tRNS_to_alpha before png_set_background_fixed.
*/ */
png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1, png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, -1,
-1); -1);
data_encoding = P_sRGB; data_encoding = P_sRGB;
/* The output will now be one or two 8-bit gray or gray+alpha /* The output will now be one or two 8-bit gray or gray+alpha
@ -2568,13 +2577,13 @@ png_image_read_colormap(png_voidp argument)
gray = png_sRGB_table[gray]; /* now P_LINEAR */ gray = png_sRGB_table[gray]; /* now P_LINEAR */
gray = PNG_DIV257(png_gamma_16bit_correct(gray, gray = PNG_DIV257(png_gamma_16bit_correct(gray,
png_ptr->colorspace.gamma)); /* now P_FILE */ png_ptr->colorspace.gamma)); /* now P_FILE */
/* And make sure the corresponding palette entry contains /* And make sure the corresponding palette entry contains
* exactly the required sRGB value. * exactly the required sRGB value.
*/ */
png_create_colormap_entry(display, gray, back_g, back_g, png_create_colormap_entry(display, gray, back_g, back_g,
back_g, 0/*unused*/, output_encoding); back_g, 0/*unused*/, output_encoding);
} }
else if (output_encoding == P_LINEAR) else if (output_encoding == P_LINEAR)
@ -2599,8 +2608,8 @@ png_image_read_colormap(png_voidp argument)
*/ */
expand_tRNS = 1; expand_tRNS = 1;
png_set_background_fixed(png_ptr, &c, png_set_background_fixed(png_ptr, &c,
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
0/*gamma: not used*/); 0/*gamma: not used*/);
} }
output_processing = PNG_CMAP_NONE; output_processing = PNG_CMAP_NONE;
@ -2634,7 +2643,7 @@ png_image_read_colormap(png_voidp argument)
/* Add a transparent entry. */ /* Add a transparent entry. */
png_create_colormap_entry(display, cmap_entries, 255, 255, png_create_colormap_entry(display, cmap_entries, 255, 255,
255, 0, P_sRGB); 255, 0, P_sRGB);
/* This is stored as the background index for the processing /* This is stored as the background index for the processing
* algorithm. * algorithm.
@ -2655,7 +2664,7 @@ png_image_read_colormap(png_voidp argument)
*/ */
for (b=0; b<256; b = (b << 1) | 0x7f) for (b=0; b<256; b = (b << 1) | 0x7f)
png_create_colormap_entry(display, cmap_entries++, png_create_colormap_entry(display, cmap_entries++,
r, g, b, 128, P_sRGB); r, g, b, 128, P_sRGB);
} }
} }
@ -2682,7 +2691,7 @@ png_image_read_colormap(png_voidp argument)
cmap_entries = make_rgb_colormap(display); cmap_entries = make_rgb_colormap(display);
png_create_colormap_entry(display, cmap_entries, back_r, png_create_colormap_entry(display, cmap_entries, back_r,
back_g, back_b, 0/*unused*/, output_encoding); back_g, back_b, 0/*unused*/, output_encoding);
if (output_encoding == P_LINEAR) if (output_encoding == P_LINEAR)
{ {
@ -2704,9 +2713,9 @@ png_image_read_colormap(png_voidp argument)
* index. * index.
*/ */
if (memcmp((png_const_bytep)display->colormap + if (memcmp((png_const_bytep)display->colormap +
sample_size * cmap_entries, sample_size * cmap_entries,
(png_const_bytep)display->colormap + (png_const_bytep)display->colormap +
sample_size * PNG_RGB_INDEX(r,g,b), sample_size * PNG_RGB_INDEX(r,g,b),
sample_size) != 0) sample_size) != 0)
{ {
/* The background color must be added. */ /* The background color must be added. */
@ -2724,13 +2733,13 @@ png_image_read_colormap(png_voidp argument)
*/ */
for (b=0; b<256; b = (b << 1) | 0x7f) for (b=0; b<256; b = (b << 1) | 0x7f)
png_create_colormap_entry(display, cmap_entries++, png_create_colormap_entry(display, cmap_entries++,
png_colormap_compose(display, r, P_sRGB, 128, png_colormap_compose(display, r, P_sRGB, 128,
back_r, output_encoding), back_r, output_encoding),
png_colormap_compose(display, g, P_sRGB, 128, png_colormap_compose(display, g, P_sRGB, 128,
back_g, output_encoding), back_g, output_encoding),
png_colormap_compose(display, b, P_sRGB, 128, png_colormap_compose(display, b, P_sRGB, 128,
back_b, output_encoding), back_b, output_encoding),
0/*unused*/, output_encoding); 0/*unused*/, output_encoding);
} }
} }
@ -2748,8 +2757,8 @@ png_image_read_colormap(png_voidp argument)
c.blue = (png_uint_16)back_b; c.blue = (png_uint_16)back_b;
png_set_background_fixed(png_ptr, &c, png_set_background_fixed(png_ptr, &c,
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
0/*gamma: not used*/); 0/*gamma: not used*/);
output_processing = PNG_CMAP_RGB; output_processing = PNG_CMAP_RGB;
} }
@ -2801,7 +2810,7 @@ png_image_read_colormap(png_voidp argument)
{ {
if (trans[i] == 0) if (trans[i] == 0)
png_create_colormap_entry(display, i, back_r, back_g, png_create_colormap_entry(display, i, back_r, back_g,
back_b, 0, output_encoding); back_b, 0, output_encoding);
else else
{ {
@ -2809,22 +2818,22 @@ png_image_read_colormap(png_voidp argument)
* on the sRGB color in 'back'. * on the sRGB color in 'back'.
*/ */
png_create_colormap_entry(display, i, png_create_colormap_entry(display, i,
png_colormap_compose(display, colormap[i].red, P_FILE, png_colormap_compose(display, colormap[i].red,
trans[i], back_r, output_encoding), P_FILE, trans[i], back_r, output_encoding),
png_colormap_compose(display, colormap[i].green, P_FILE, png_colormap_compose(display, colormap[i].green,
trans[i], back_g, output_encoding), P_FILE, trans[i], back_g, output_encoding),
png_colormap_compose(display, colormap[i].blue, P_FILE, png_colormap_compose(display, colormap[i].blue,
trans[i], back_b, output_encoding), P_FILE, trans[i], back_b, output_encoding),
output_encoding == P_LINEAR ? trans[i] * 257U : output_encoding == P_LINEAR ? trans[i] * 257U :
trans[i], trans[i],
output_encoding); output_encoding);
} }
} }
else else
png_create_colormap_entry(display, i, colormap[i].red, png_create_colormap_entry(display, i, colormap[i].red,
colormap[i].green, colormap[i].blue, colormap[i].green, colormap[i].blue,
i < num_trans ? trans[i] : 255U, P_FILE/*8-bit*/); i < num_trans ? trans[i] : 255U, P_FILE/*8-bit*/);
} }
/* The PNG data may have indices packed in fewer than 8 bits, it /* The PNG data may have indices packed in fewer than 8 bits, it
@ -2914,7 +2923,7 @@ static int
png_image_read_and_map(png_voidp argument) png_image_read_and_map(png_voidp argument)
{ {
png_image_read_control *display = png_voidcast(png_image_read_control*, png_image_read_control *display = png_voidcast(png_image_read_control*,
argument); argument);
png_imagep image = display->image; png_imagep image = display->image;
png_structrp png_ptr = image->opaque->png_ptr; png_structrp png_ptr = image->opaque->png_ptr;
int passes; int passes;
@ -3051,7 +3060,7 @@ png_image_read_and_map(png_voidp argument)
if (alpha >= 196) if (alpha >= 196)
*outrow = PNG_RGB_INDEX(inrow[0], inrow[1], *outrow = PNG_RGB_INDEX(inrow[0], inrow[1],
inrow[2]); inrow[2]);
else if (alpha < 64) else if (alpha < 64)
*outrow = PNG_CMAP_RGB_ALPHA_BACKGROUND; *outrow = PNG_CMAP_RGB_ALPHA_BACKGROUND;
@ -3103,7 +3112,7 @@ static int
png_image_read_colormapped(png_voidp argument) png_image_read_colormapped(png_voidp argument)
{ {
png_image_read_control *display = png_voidcast(png_image_read_control*, png_image_read_control *display = png_voidcast(png_image_read_control*,
argument); argument);
png_imagep image = display->image; png_imagep image = display->image;
png_controlp control = image->opaque; png_controlp control = image->opaque;
png_structrp png_ptr = control->png_ptr; png_structrp png_ptr = control->png_ptr;
@ -3236,7 +3245,7 @@ static int
png_image_read_composite(png_voidp argument) png_image_read_composite(png_voidp argument)
{ {
png_image_read_control *display = png_voidcast(png_image_read_control*, png_image_read_control *display = png_voidcast(png_image_read_control*,
argument); argument);
png_imagep image = display->image; png_imagep image = display->image;
png_structrp png_ptr = image->opaque->png_ptr; png_structrp png_ptr = image->opaque->png_ptr;
int passes; int passes;
@ -3363,7 +3372,7 @@ static int
png_image_read_background(png_voidp argument) png_image_read_background(png_voidp argument)
{ {
png_image_read_control *display = png_voidcast(png_image_read_control*, png_image_read_control *display = png_voidcast(png_image_read_control*,
argument); argument);
png_imagep image = display->image; png_imagep image = display->image;
png_structrp png_ptr = image->opaque->png_ptr; png_structrp png_ptr = image->opaque->png_ptr;
png_inforp info_ptr = image->opaque->info_ptr; png_inforp info_ptr = image->opaque->info_ptr;
@ -3423,8 +3432,7 @@ png_image_read_background(png_voidp argument)
for (pass = 0; pass < passes; ++pass) for (pass = 0; pass < passes; ++pass)
{ {
png_bytep row = png_voidcast(png_bytep, png_bytep row = png_voidcast(png_bytep, display->first_row);
display->first_row);
unsigned int startx, stepx, stepy; unsigned int startx, stepx, stepy;
png_uint_32 y; png_uint_32 y;
@ -3452,7 +3460,7 @@ png_image_read_background(png_voidp argument)
for (; y<height; y += stepy) for (; y<height; y += stepy)
{ {
png_bytep inrow = png_voidcast(png_bytep, png_bytep inrow = png_voidcast(png_bytep,
display->local_row); display->local_row);
png_bytep outrow = first_row + y * step_row; png_bytep outrow = first_row + y * step_row;
png_const_bytep end_row = outrow + width; png_const_bytep end_row = outrow + width;
@ -3497,7 +3505,7 @@ png_image_read_background(png_voidp argument)
for (; y<height; y += stepy) for (; y<height; y += stepy)
{ {
png_bytep inrow = png_voidcast(png_bytep, png_bytep inrow = png_voidcast(png_bytep,
display->local_row); display->local_row);
png_bytep outrow = first_row + y * step_row; png_bytep outrow = first_row + y * step_row;
png_const_bytep end_row = outrow + width; png_const_bytep end_row = outrow + width;
@ -3544,7 +3552,7 @@ png_image_read_background(png_voidp argument)
*/ */
{ {
png_uint_16p first_row = png_voidcast(png_uint_16p, png_uint_16p first_row = png_voidcast(png_uint_16p,
display->first_row); display->first_row);
/* The division by two is safe because the caller passed in a /* The division by two is safe because the caller passed in a
* stride which was multiplied by 2 (below) to get row_bytes. * stride which was multiplied by 2 (below) to get row_bytes.
*/ */
@ -3594,7 +3602,7 @@ png_image_read_background(png_voidp argument)
/* Read the row, which is packed: */ /* Read the row, which is packed: */
png_read_row(png_ptr, png_voidcast(png_bytep, png_read_row(png_ptr, png_voidcast(png_bytep,
display->local_row), NULL); display->local_row), NULL);
inrow = png_voidcast(png_const_uint_16p, display->local_row); inrow = png_voidcast(png_const_uint_16p, display->local_row);
/* Now do the pre-multiplication on each pixel in this row. /* Now do the pre-multiplication on each pixel in this row.
@ -3643,7 +3651,7 @@ static int
png_image_read_direct(png_voidp argument) png_image_read_direct(png_voidp argument)
{ {
png_image_read_control *display = png_voidcast(png_image_read_control*, png_image_read_control *display = png_voidcast(png_image_read_control*,
argument); argument);
png_imagep image = display->image; png_imagep image = display->image;
png_structrp png_ptr = image->opaque->png_ptr; png_structrp png_ptr = image->opaque->png_ptr;
png_inforp info_ptr = image->opaque->info_ptr; png_inforp info_ptr = image->opaque->info_ptr;
@ -3694,7 +3702,7 @@ png_image_read_direct(png_voidp argument)
do_local_background = 1/*maybe*/; do_local_background = 1/*maybe*/;
png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE, png_set_rgb_to_gray_fixed(png_ptr, PNG_ERROR_ACTION_NONE,
PNG_RGB_TO_GRAY_DEFAULT, PNG_RGB_TO_GRAY_DEFAULT); PNG_RGB_TO_GRAY_DEFAULT, PNG_RGB_TO_GRAY_DEFAULT);
} }
change &= ~PNG_FORMAT_FLAG_COLOR; change &= ~PNG_FORMAT_FLAG_COLOR;
@ -3753,7 +3761,7 @@ png_image_read_direct(png_voidp argument)
* final value. * final value.
*/ */
if (png_muldiv(&gtest, output_gamma, png_ptr->colorspace.gamma, if (png_muldiv(&gtest, output_gamma, png_ptr->colorspace.gamma,
PNG_FP_1) != 0 && png_gamma_significant(gtest) == 0) PNG_FP_1) != 0 && png_gamma_significant(gtest) == 0)
do_local_background = 0; do_local_background = 0;
else if (mode == PNG_ALPHA_STANDARD) else if (mode == PNG_ALPHA_STANDARD)
@ -3816,8 +3824,8 @@ png_image_read_direct(png_voidp argument)
* pixels. * pixels.
*/ */
png_set_background_fixed(png_ptr, &c, png_set_background_fixed(png_ptr, &c,
PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/, PNG_BACKGROUND_GAMMA_SCREEN, 0/*need_expand*/,
0/*gamma: not used*/); 0/*gamma: not used*/);
} }
else /* compose on row: implemented below. */ else /* compose on row: implemented below. */
@ -3848,16 +3856,16 @@ png_image_read_direct(png_voidp argument)
else else
filler = 255; filler = 255;
# ifdef PNG_FORMAT_AFIRST_SUPPORTED #ifdef PNG_FORMAT_AFIRST_SUPPORTED
if ((format & PNG_FORMAT_FLAG_AFIRST) != 0) if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
where = PNG_FILLER_BEFORE; where = PNG_FILLER_BEFORE;
change &= ~PNG_FORMAT_FLAG_AFIRST; change &= ~PNG_FORMAT_FLAG_AFIRST;
} }
else else
# endif #endif
where = PNG_FILLER_AFTER; where = PNG_FILLER_AFTER;
png_set_add_alpha(png_ptr, filler, where); png_set_add_alpha(png_ptr, filler, where);
} }
@ -3965,12 +3973,12 @@ png_image_read_direct(png_voidp argument)
if (info_ptr->bit_depth == 16) if (info_ptr->bit_depth == 16)
info_format |= PNG_FORMAT_FLAG_LINEAR; info_format |= PNG_FORMAT_FLAG_LINEAR;
# ifdef PNG_FORMAT_BGR_SUPPORTED #ifdef PNG_FORMAT_BGR_SUPPORTED
if ((png_ptr->transformations & PNG_BGR) != 0) if ((png_ptr->transformations & PNG_BGR) != 0)
info_format |= PNG_FORMAT_FLAG_BGR; info_format |= PNG_FORMAT_FLAG_BGR;
# endif #endif
# ifdef PNG_FORMAT_AFIRST_SUPPORTED #ifdef PNG_FORMAT_AFIRST_SUPPORTED
if (do_local_background == 2) if (do_local_background == 2)
{ {
if ((format & PNG_FORMAT_FLAG_AFIRST) != 0) if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
@ -4067,67 +4075,117 @@ png_image_read_direct(png_voidp argument)
int PNGAPI int PNGAPI
png_image_finish_read(png_imagep image, png_const_colorp background, png_image_finish_read(png_imagep image, png_const_colorp background,
void *buffer, png_int_32 row_stride, void *colormap) void *buffer, png_int_32 row_stride, void *colormap)
{ {
if (image != NULL && image->version == PNG_IMAGE_VERSION) if (image != NULL && image->version == PNG_IMAGE_VERSION)
{ {
png_uint_32 check; /* Check for row_stride overflow. This check is not performed on the
* original PNG format because it may not occur in the output PNG format
* and libpng deals with the issues of reading the original.
*/
const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
if (row_stride == 0) /* The following checks just the 'row_stride' calculation to ensure it
row_stride = PNG_IMAGE_ROW_STRIDE(*image); * fits in a signed 32-bit value. Because channels/components can be
* either 1 or 2 bytes in size the length of a row can still overflow 32
if (row_stride < 0) * bits; this is just to verify that the 'row_stride' argument can be
check = -row_stride; * represented.
*/
else if (image->width <= 0x7FFFFFFFU/channels) /* no overflow */
check = row_stride;
if (image->opaque != NULL && buffer != NULL &&
check >= PNG_IMAGE_ROW_STRIDE(*image))
{ {
if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 || png_uint_32 check;
(image->colormap_entries > 0 && colormap != NULL)) const png_uint_32 png_row_stride = image->width * channels;
if (row_stride == 0)
row_stride = (png_int_32)/*SAFE*/png_row_stride;
if (row_stride < 0)
check = -row_stride;
else
check = row_stride;
/* This verifies 'check', the absolute value of the actual stride
* passed in and detects overflow in the application calculation (i.e.
* if the app did actually pass in a non-zero 'row_stride'.
*/
if (image->opaque != NULL && buffer != NULL && check >= png_row_stride)
{ {
int result; /* Now check for overflow of the image buffer calculation; this
png_image_read_control display; * limits the whole image size to 32 bits for API compatibility with
* the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
memset(&display, 0, (sizeof display)); *
display.image = image; * The PNG_IMAGE_BUFFER_SIZE macro is:
display.buffer = buffer; *
display.row_stride = row_stride; * (PNG_IMAGE_PIXEL_COMPONENT_SIZE(fmt)*height*(row_stride))
display.colormap = colormap; *
display.background = background; * And the component size is always 1 or 2, so make sure that the
display.local_row = NULL; * number of *bytes* that the application is saying are available
* does actually fit into a 32-bit number.
/* Choose the correct 'end' routine; for the color-map case all the *
* setup has already been done. * NOTE: this will be changed in 1.7 because PNG_IMAGE_BUFFER_SIZE
* will be changed to use png_alloc_size_t; bigger images can be
* accomodated on 64-bit systems.
*/ */
if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0) if (image->height <=
result = 0xFFFFFFFFU/PNG_IMAGE_PIXEL_COMPONENT_SIZE(image->format)/check)
png_safe_execute(image, png_image_read_colormap, &display) && {
png_safe_execute(image, png_image_read_colormapped, &display); if ((image->format & PNG_FORMAT_FLAG_COLORMAP) == 0 ||
(image->colormap_entries > 0 && colormap != NULL))
{
int result;
png_image_read_control display;
memset(&display, 0, (sizeof display));
display.image = image;
display.buffer = buffer;
display.row_stride = row_stride;
display.colormap = colormap;
display.background = background;
display.local_row = NULL;
/* Choose the correct 'end' routine; for the color-map case
* all the setup has already been done.
*/
if ((image->format & PNG_FORMAT_FLAG_COLORMAP) != 0)
result =
png_safe_execute(image,
png_image_read_colormap, &display) &&
png_safe_execute(image,
png_image_read_colormapped, &display);
else
result =
png_safe_execute(image,
png_image_read_direct, &display);
png_image_free(image);
return result;
}
else
return png_image_error(image,
"png_image_finish_read[color-map]: no color-map");
}
else else
result = return png_image_error(image,
png_safe_execute(image, png_image_read_direct, &display); "png_image_finish_read: image too large");
png_image_free(image);
return result;
} }
else else
return png_image_error(image, return png_image_error(image,
"png_image_finish_read[color-map]: no color-map"); "png_image_finish_read: invalid argument");
} }
else else
return png_image_error(image, return png_image_error(image,
"png_image_finish_read: invalid argument"); "png_image_finish_read: row_stride too large");
} }
else if (image != NULL) else if (image != NULL)
return png_image_error(image, return png_image_error(image,
"png_image_finish_read: damaged PNG_IMAGE_VERSION"); "png_image_finish_read: damaged PNG_IMAGE_VERSION");
return 0; return 0;
} }

6
thirdparty/libpng/pngrio.c vendored
View File

@ -1,8 +1,8 @@
/* pngrio.c - functions for data input /* pngrio.c - functions for data input
* *
* Last changed in libpng 1.6.17 [March 26, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -85,7 +85,7 @@ png_default_read_data(png_structp png_ptr, png_bytep data, png_size_t length)
*/ */
void PNGAPI void PNGAPI
png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr, png_set_read_fn(png_structrp png_ptr, png_voidp io_ptr,
png_rw_ptr read_data_fn) png_rw_ptr read_data_fn)
{ {
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;

63
thirdparty/libpng/pngrtran.c vendored
View File

@ -1,8 +1,8 @@
/* pngrtran.c - transforms the data in a row for PNG readers /* pngrtran.c - transforms the data in a row for PNG readers
* *
* Last changed in libpng 1.6.19 [November 12, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -48,7 +48,7 @@ png_set_crc_action(png_structrp png_ptr, int crit_action, int ancil_action)
case PNG_CRC_WARN_DISCARD: /* Not a valid action for critical data */ case PNG_CRC_WARN_DISCARD: /* Not a valid action for critical data */
png_warning(png_ptr, png_warning(png_ptr,
"Can't discard critical data on CRC error"); "Can't discard critical data on CRC error");
case PNG_CRC_ERROR_QUIT: /* Error/quit */ case PNG_CRC_ERROR_QUIT: /* Error/quit */
case PNG_CRC_DEFAULT: case PNG_CRC_DEFAULT:
@ -101,7 +101,7 @@ png_rtran_ok(png_structrp png_ptr, int need_IHDR)
{ {
if ((png_ptr->flags & PNG_FLAG_ROW_INIT) != 0) if ((png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
png_app_error(png_ptr, png_app_error(png_ptr,
"invalid after png_start_read_image or png_read_update_info"); "invalid after png_start_read_image or png_read_update_info");
else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0) else if (need_IHDR && (png_ptr->mode & PNG_HAVE_IHDR) == 0)
png_app_error(png_ptr, "invalid before the PNG header has been read"); png_app_error(png_ptr, "invalid before the PNG header has been read");
@ -159,7 +159,7 @@ png_set_background(png_structrp png_ptr,
png_set_background_fixed(png_ptr, background_color, background_gamma_code, png_set_background_fixed(png_ptr, background_color, background_gamma_code,
need_expand, png_fixed(png_ptr, background_gamma, "png_set_background")); need_expand, png_fixed(png_ptr, background_gamma, "png_set_background"));
} }
# endif /* FLOATING_POINT */ # endif /* FLOATING_POINT */
#endif /* READ_BACKGROUND */ #endif /* READ_BACKGROUND */
/* Scale 16-bit depth files to 8-bit depth. If both of these are set then the /* Scale 16-bit depth files to 8-bit depth. If both of these are set then the
@ -209,7 +209,7 @@ png_set_strip_alpha(png_structrp png_ptr)
#if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED) #if defined(PNG_READ_ALPHA_MODE_SUPPORTED) || defined(PNG_READ_GAMMA_SUPPORTED)
static png_fixed_point static png_fixed_point
translate_gamma_flags(png_structrp png_ptr, png_fixed_point output_gamma, translate_gamma_flags(png_structrp png_ptr, png_fixed_point output_gamma,
int is_screen) int is_screen)
{ {
/* Check for flag values. The main reason for having the old Mac value as a /* Check for flag values. The main reason for having the old Mac value as a
* flag is that it is pretty near impossible to work out what the correct * flag is that it is pretty near impossible to work out what the correct
@ -273,7 +273,7 @@ convert_gamma_value(png_structrp png_ptr, double output_gamma)
#ifdef PNG_READ_ALPHA_MODE_SUPPORTED #ifdef PNG_READ_ALPHA_MODE_SUPPORTED
void PNGFAPI void PNGFAPI
png_set_alpha_mode_fixed(png_structrp png_ptr, int mode, png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
png_fixed_point output_gamma) png_fixed_point output_gamma)
{ {
int compose = 0; int compose = 0;
png_fixed_point file_gamma; png_fixed_point file_gamma;
@ -289,9 +289,12 @@ png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
* is expected to be 1 or greater, but this range test allows for some * is expected to be 1 or greater, but this range test allows for some
* viewing correction values. The intent is to weed out users of this API * viewing correction values. The intent is to weed out users of this API
* who use the inverse of the gamma value accidentally! Since some of these * who use the inverse of the gamma value accidentally! Since some of these
* values are reasonable this may have to be changed. * values are reasonable this may have to be changed:
*
* 1.6.x: changed from 0.07..3 to 0.01..100 (to accomodate the optimal 16-bit
* gamma of 36, and its reciprocal.)
*/ */
if (output_gamma < 70000 || output_gamma > 300000) if (output_gamma < 1000 || output_gamma > 10000000)
png_error(png_ptr, "output gamma out of expected range"); png_error(png_ptr, "output gamma out of expected range");
/* The default file gamma is the inverse of the output gamma; the output /* The default file gamma is the inverse of the output gamma; the output
@ -374,7 +377,7 @@ png_set_alpha_mode_fixed(png_structrp png_ptr, int mode,
if ((png_ptr->transformations & PNG_COMPOSE) != 0) if ((png_ptr->transformations & PNG_COMPOSE) != 0)
png_error(png_ptr, png_error(png_ptr,
"conflicting calls to set alpha mode and background"); "conflicting calls to set alpha mode and background");
png_ptr->transformations |= PNG_COMPOSE; png_ptr->transformations |= PNG_COMPOSE;
} }
@ -385,7 +388,7 @@ void PNGAPI
png_set_alpha_mode(png_structrp png_ptr, int mode, double output_gamma) png_set_alpha_mode(png_structrp png_ptr, int mode, double output_gamma)
{ {
png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr, png_set_alpha_mode_fixed(png_ptr, mode, convert_gamma_value(png_ptr,
output_gamma)); output_gamma));
} }
# endif # endif
#endif #endif
@ -799,7 +802,7 @@ png_set_quantize(png_structrp png_ptr, png_colorp palette,
#ifdef PNG_READ_GAMMA_SUPPORTED #ifdef PNG_READ_GAMMA_SUPPORTED
void PNGFAPI void PNGFAPI
png_set_gamma_fixed(png_structrp png_ptr, png_fixed_point scrn_gamma, png_set_gamma_fixed(png_structrp png_ptr, png_fixed_point scrn_gamma,
png_fixed_point file_gamma) png_fixed_point file_gamma)
{ {
png_debug(1, "in png_set_gamma_fixed"); png_debug(1, "in png_set_gamma_fixed");
@ -841,7 +844,7 @@ void PNGAPI
png_set_gamma(png_structrp png_ptr, double scrn_gamma, double file_gamma) png_set_gamma(png_structrp png_ptr, double scrn_gamma, double file_gamma)
{ {
png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma), png_set_gamma_fixed(png_ptr, convert_gamma_value(png_ptr, scrn_gamma),
convert_gamma_value(png_ptr, file_gamma)); convert_gamma_value(png_ptr, file_gamma));
} }
# endif /* FLOATING_POINT */ # endif /* FLOATING_POINT */
#endif /* READ_GAMMA */ #endif /* READ_GAMMA */
@ -987,7 +990,7 @@ png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
* that it just worked and get a memory overwrite. * that it just worked and get a memory overwrite.
*/ */
png_error(png_ptr, png_error(png_ptr,
"Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED"); "Cannot do RGB_TO_GRAY without EXPAND_SUPPORTED");
/* png_ptr->transformations &= ~PNG_RGB_TO_GRAY; */ /* png_ptr->transformations &= ~PNG_RGB_TO_GRAY; */
} }
@ -1014,7 +1017,7 @@ png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
{ {
if (red >= 0 && green >= 0) if (red >= 0 && green >= 0)
png_app_warning(png_ptr, png_app_warning(png_ptr,
"ignoring out of range rgb_to_gray coefficients"); "ignoring out of range rgb_to_gray coefficients");
/* Use the defaults, from the cHRM chunk if set, else the historical /* Use the defaults, from the cHRM chunk if set, else the historical
* values which are close to the sRGB/HDTV/ITU-Rec 709 values. See * values which are close to the sRGB/HDTV/ITU-Rec 709 values. See
@ -1023,7 +1026,7 @@ png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
* something has already provided a default. * something has already provided a default.
*/ */
if (png_ptr->rgb_to_gray_red_coeff == 0 && if (png_ptr->rgb_to_gray_red_coeff == 0 &&
png_ptr->rgb_to_gray_green_coeff == 0) png_ptr->rgb_to_gray_green_coeff == 0)
{ {
png_ptr->rgb_to_gray_red_coeff = 6968; png_ptr->rgb_to_gray_red_coeff = 6968;
png_ptr->rgb_to_gray_green_coeff = 23434; png_ptr->rgb_to_gray_green_coeff = 23434;
@ -1040,10 +1043,10 @@ png_set_rgb_to_gray_fixed(png_structrp png_ptr, int error_action,
void PNGAPI void PNGAPI
png_set_rgb_to_gray(png_structrp png_ptr, int error_action, double red, png_set_rgb_to_gray(png_structrp png_ptr, int error_action, double red,
double green) double green)
{ {
png_set_rgb_to_gray_fixed(png_ptr, error_action, png_set_rgb_to_gray_fixed(png_ptr, error_action,
png_fixed(png_ptr, red, "rgb to gray red coefficient"), png_fixed(png_ptr, red, "rgb to gray red coefficient"),
png_fixed(png_ptr, green, "rgb to gray green coefficient")); png_fixed(png_ptr, green, "rgb to gray green coefficient"));
} }
#endif /* FLOATING POINT */ #endif /* FLOATING POINT */
@ -1300,7 +1303,7 @@ png_init_read_transformations(png_structrp png_ptr)
{ {
if (png_ptr->screen_gamma != 0) /* screen set too */ if (png_ptr->screen_gamma != 0) /* screen set too */
gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma, gamma_correction = png_gamma_threshold(png_ptr->colorspace.gamma,
png_ptr->screen_gamma); png_ptr->screen_gamma);
else else
/* Assume the output matches the input; a long time default behavior /* Assume the output matches the input; a long time default behavior
@ -1581,7 +1584,7 @@ png_init_read_transformations(png_structrp png_ptr)
*/ */
if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0) if ((png_ptr->transformations & PNG_RGB_TO_GRAY) != 0)
png_warning(png_ptr, png_warning(png_ptr,
"libpng does not support gamma+background+rgb_to_gray"); "libpng does not support gamma+background+rgb_to_gray");
if ((png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) != 0) if ((png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) != 0)
{ {
@ -1617,13 +1620,13 @@ png_init_read_transformations(png_structrp png_ptr)
case PNG_BACKGROUND_GAMMA_FILE: case PNG_BACKGROUND_GAMMA_FILE:
g = png_reciprocal(png_ptr->colorspace.gamma); g = png_reciprocal(png_ptr->colorspace.gamma);
gs = png_reciprocal2(png_ptr->colorspace.gamma, gs = png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr->screen_gamma); png_ptr->screen_gamma);
break; break;
case PNG_BACKGROUND_GAMMA_UNIQUE: case PNG_BACKGROUND_GAMMA_UNIQUE:
g = png_reciprocal(png_ptr->background_gamma); g = png_reciprocal(png_ptr->background_gamma);
gs = png_reciprocal2(png_ptr->background_gamma, gs = png_reciprocal2(png_ptr->background_gamma,
png_ptr->screen_gamma); png_ptr->screen_gamma);
break; break;
default: default:
g = PNG_FP_1; /* back_1 */ g = PNG_FP_1; /* back_1 */
@ -1651,11 +1654,11 @@ png_init_read_transformations(png_structrp png_ptr)
if (png_gamma_significant(g) != 0) if (png_gamma_significant(g) != 0)
{ {
back_1.red = png_gamma_8bit_correct(png_ptr->background.red, back_1.red = png_gamma_8bit_correct(png_ptr->background.red,
g); g);
back_1.green = png_gamma_8bit_correct( back_1.green = png_gamma_8bit_correct(
png_ptr->background.green, g); png_ptr->background.green, g);
back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue, back_1.blue = png_gamma_8bit_correct(png_ptr->background.blue,
g); g);
} }
else else
@ -1726,7 +1729,7 @@ png_init_read_transformations(png_structrp png_ptr)
case PNG_BACKGROUND_GAMMA_FILE: case PNG_BACKGROUND_GAMMA_FILE:
g = png_reciprocal(png_ptr->colorspace.gamma); g = png_reciprocal(png_ptr->colorspace.gamma);
gs = png_reciprocal2(png_ptr->colorspace.gamma, gs = png_reciprocal2(png_ptr->colorspace.gamma,
png_ptr->screen_gamma); png_ptr->screen_gamma);
break; break;
case PNG_BACKGROUND_GAMMA_UNIQUE: case PNG_BACKGROUND_GAMMA_UNIQUE:
@ -1912,7 +1915,7 @@ png_init_read_transformations(png_structrp png_ptr)
png_ptr->palette[i].blue = (png_byte)component; png_ptr->palette[i].blue = (png_byte)component;
} }
} }
#endif /* READ_SHIFT */ #endif /* READ_SHIFT */
} }
/* Modify the info structure to reflect the transformations. The /* Modify the info structure to reflect the transformations. The
@ -4192,7 +4195,7 @@ png_do_encode_alpha(png_row_infop row_info, png_bytep row, png_structrp png_ptr)
*/ */
static void static void
png_do_expand_palette(png_row_infop row_info, png_bytep row, png_do_expand_palette(png_row_infop row_info, png_bytep row,
png_const_colorp palette, png_const_bytep trans_alpha, int num_trans) png_const_colorp palette, png_const_bytep trans_alpha, int num_trans)
{ {
int shift, value; int shift, value;
png_bytep sp, dp; png_bytep sp, dp;
@ -4499,7 +4502,7 @@ png_do_expand(png_row_infop row_info, png_bytep row,
row_info->channels = 2; row_info->channels = 2;
row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1); row_info->pixel_depth = (png_byte)(row_info->bit_depth << 1);
row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth, row_info->rowbytes = PNG_ROWBYTES(row_info->pixel_depth,
row_width); row_width);
} }
} }
else if (row_info->color_type == PNG_COLOR_TYPE_RGB && else if (row_info->color_type == PNG_COLOR_TYPE_RGB &&
@ -4759,7 +4762,7 @@ png_do_read_transformations(png_structrp png_ptr, png_row_infop row_info)
(row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA || (row_info->color_type == PNG_COLOR_TYPE_RGB_ALPHA ||
row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA)) row_info->color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
png_do_strip_channel(row_info, png_ptr->row_buf + 1, png_do_strip_channel(row_info, png_ptr->row_buf + 1,
0 /* at_start == false, because SWAP_ALPHA happens later */); 0 /* at_start == false, because SWAP_ALPHA happens later */);
#endif #endif
#ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED

192
thirdparty/libpng/pngrutil.c vendored
View File

@ -1,8 +1,8 @@
/* pngrutil.c - utilities to read a PNG file /* pngrutil.c - utilities to read a PNG file
* *
* Last changed in libpng 1.6.20 [December 3, 2014] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -90,7 +90,7 @@ png_get_int_32)(png_const_bytep buf)
uval = (uval ^ 0xffffffff) + 1; /* 2's complement: -x = ~x+1 */ uval = (uval ^ 0xffffffff) + 1; /* 2's complement: -x = ~x+1 */
if ((uval & 0x80000000) == 0) /* no overflow */ if ((uval & 0x80000000) == 0) /* no overflow */
return -(png_int_32)uval; return -(png_int_32)uval;
/* The following has to be safe; this function only gets called on PNG data /* The following has to be safe; this function only gets called on PNG data
* and if we get here that data is invalid. 0 is the most safe value and * and if we get here that data is invalid. 0 is the most safe value and
* if not then an attacker would surely just generate a PNG with 0 instead. * if not then an attacker would surely just generate a PNG with 0 instead.
@ -590,6 +590,7 @@ png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish,
} }
} }
#if defined(PNG_READ_zTXt_SUPPORTED) || defined (PNG_READ_iTXt_SUPPORTED)
/* /*
* Decompress trailing data in a chunk. The assumption is that read_buffer * Decompress trailing data in a chunk. The assumption is that read_buffer
* points at an allocated area holding the contents of a chunk with a * points at an allocated area holding the contents of a chunk with a
@ -599,9 +600,9 @@ png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish,
*/ */
static int static int
png_decompress_chunk(png_structrp png_ptr, png_decompress_chunk(png_structrp png_ptr,
png_uint_32 chunklength, png_uint_32 prefix_size, png_uint_32 chunklength, png_uint_32 prefix_size,
png_alloc_size_t *newlength /* must be initialized to the maximum! */, png_alloc_size_t *newlength /* must be initialized to the maximum! */,
int terminate /*add a '\0' to the end of the uncompressed data*/) int terminate /*add a '\0' to the end of the uncompressed data*/)
{ {
/* TODO: implement different limits for different types of chunk. /* TODO: implement different limits for different types of chunk.
* *
@ -638,8 +639,8 @@ png_decompress_chunk(png_structrp png_ptr,
png_uint_32 lzsize = chunklength - prefix_size; png_uint_32 lzsize = chunklength - prefix_size;
ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/, ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
/* input: */ png_ptr->read_buffer + prefix_size, &lzsize, /* input: */ png_ptr->read_buffer + prefix_size, &lzsize,
/* output: */ NULL, newlength); /* output: */ NULL, newlength);
if (ret == Z_STREAM_END) if (ret == Z_STREAM_END)
{ {
@ -659,15 +660,15 @@ png_decompress_chunk(png_structrp png_ptr,
*/ */
png_alloc_size_t new_size = *newlength; png_alloc_size_t new_size = *newlength;
png_alloc_size_t buffer_size = prefix_size + new_size + png_alloc_size_t buffer_size = prefix_size + new_size +
(terminate != 0); (terminate != 0);
png_bytep text = png_voidcast(png_bytep, png_malloc_base(png_ptr, png_bytep text = png_voidcast(png_bytep, png_malloc_base(png_ptr,
buffer_size)); buffer_size));
if (text != NULL) if (text != NULL)
{ {
ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/, ret = png_inflate(png_ptr, png_ptr->chunk_name, 1/*finish*/,
png_ptr->read_buffer + prefix_size, &lzsize, png_ptr->read_buffer + prefix_size, &lzsize,
text + prefix_size, newlength); text + prefix_size, newlength);
if (ret == Z_STREAM_END) if (ret == Z_STREAM_END)
{ {
@ -754,6 +755,7 @@ png_decompress_chunk(png_structrp png_ptr,
return Z_MEM_ERROR; return Z_MEM_ERROR;
} }
} }
#endif /* READ_zTXt || READ_iTXt */
#endif /* READ_COMPRESSED_TEXT */ #endif /* READ_COMPRESSED_TEXT */
#ifdef PNG_READ_iCCP_SUPPORTED #ifdef PNG_READ_iCCP_SUPPORTED
@ -762,8 +764,8 @@ png_decompress_chunk(png_structrp png_ptr,
*/ */
static int static int
png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size, png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size,
png_uint_32p chunk_bytes, png_bytep next_out, png_alloc_size_t *out_size, png_uint_32p chunk_bytes, png_bytep next_out, png_alloc_size_t *out_size,
int finish) int finish)
{ {
if (png_ptr->zowner == png_ptr->chunk_name) if (png_ptr->zowner == png_ptr->chunk_name)
{ {
@ -802,8 +804,8 @@ png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size,
* the available output is produced; this allows reading of truncated * the available output is produced; this allows reading of truncated
* streams. * streams.
*/ */
ret = PNG_INFLATE(png_ptr, ret = PNG_INFLATE(png_ptr, *chunk_bytes > 0 ?
*chunk_bytes > 0 ? Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH)); Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH));
} }
while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0)); while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0));
@ -1292,7 +1294,7 @@ png_handle_cHRM(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
png_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM; png_ptr->colorspace.flags |= PNG_COLORSPACE_FROM_cHRM;
(void)png_colorspace_set_chromaticities(png_ptr, &png_ptr->colorspace, &xy, (void)png_colorspace_set_chromaticities(png_ptr, &png_ptr->colorspace, &xy,
1/*prefer cHRM values*/); 1/*prefer cHRM values*/);
png_colorspace_sync(png_ptr, info_ptr); png_colorspace_sync(png_ptr, info_ptr);
} }
#endif #endif
@ -1432,8 +1434,8 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
png_ptr->zstream.next_in = (Bytef*)keyword + (keyword_length+2); png_ptr->zstream.next_in = (Bytef*)keyword + (keyword_length+2);
png_ptr->zstream.avail_in = read_length; png_ptr->zstream.avail_in = read_length;
(void)png_inflate_read(png_ptr, local_buffer, (void)png_inflate_read(png_ptr, local_buffer,
(sizeof local_buffer), &length, profile_header, &size, (sizeof local_buffer), &length, profile_header, &size,
0/*finish: don't, because the output is too small*/); 0/*finish: don't, because the output is too small*/);
if (size == 0) if (size == 0)
{ {
@ -1443,14 +1445,14 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
png_get_uint_32(profile_header); png_get_uint_32(profile_header);
if (png_icc_check_length(png_ptr, &png_ptr->colorspace, if (png_icc_check_length(png_ptr, &png_ptr->colorspace,
keyword, profile_length) != 0) keyword, profile_length) != 0)
{ {
/* The length is apparently ok, so we can check the 132 /* The length is apparently ok, so we can check the 132
* byte header. * byte header.
*/ */
if (png_icc_check_header(png_ptr, &png_ptr->colorspace, if (png_icc_check_header(png_ptr, &png_ptr->colorspace,
keyword, profile_length, profile_header, keyword, profile_length, profile_header,
png_ptr->color_type) != 0) png_ptr->color_type) != 0)
{ {
/* Now read the tag table; a variable size buffer is /* Now read the tag table; a variable size buffer is
* needed at this point, allocate one for the whole * needed at this point, allocate one for the whole
@ -1458,20 +1460,20 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
* that none of these stuff will overflow. * that none of these stuff will overflow.
*/ */
const png_uint_32 tag_count = png_get_uint_32( const png_uint_32 tag_count = png_get_uint_32(
profile_header+128); profile_header+128);
png_bytep profile = png_read_buffer(png_ptr, png_bytep profile = png_read_buffer(png_ptr,
profile_length, 2/*silent*/); profile_length, 2/*silent*/);
if (profile != NULL) if (profile != NULL)
{ {
memcpy(profile, profile_header, memcpy(profile, profile_header,
(sizeof profile_header)); (sizeof profile_header));
size = 12 * tag_count; size = 12 * tag_count;
(void)png_inflate_read(png_ptr, local_buffer, (void)png_inflate_read(png_ptr, local_buffer,
(sizeof local_buffer), &length, (sizeof local_buffer), &length,
profile + (sizeof profile_header), &size, 0); profile + (sizeof profile_header), &size, 0);
/* Still expect a buffer error because we expect /* Still expect a buffer error because we expect
* there to be some tag data! * there to be some tag data!
@ -1479,22 +1481,22 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
if (size == 0) if (size == 0)
{ {
if (png_icc_check_tag_table(png_ptr, if (png_icc_check_tag_table(png_ptr,
&png_ptr->colorspace, keyword, profile_length, &png_ptr->colorspace, keyword, profile_length,
profile) != 0) profile) != 0)
{ {
/* The profile has been validated for basic /* The profile has been validated for basic
* security issues, so read the whole thing in. * security issues, so read the whole thing in.
*/ */
size = profile_length - (sizeof profile_header) size = profile_length - (sizeof profile_header)
- 12 * tag_count; - 12 * tag_count;
(void)png_inflate_read(png_ptr, local_buffer, (void)png_inflate_read(png_ptr, local_buffer,
(sizeof local_buffer), &length, (sizeof local_buffer), &length,
profile + (sizeof profile_header) + profile + (sizeof profile_header) +
12 * tag_count, &size, 1/*finish*/); 12 * tag_count, &size, 1/*finish*/);
if (length > 0 && !(png_ptr->flags & if (length > 0 && !(png_ptr->flags &
PNG_FLAG_BENIGN_ERRORS_WARN)) PNG_FLAG_BENIGN_ERRORS_WARN))
errmsg = "extra compressed data"; errmsg = "extra compressed data";
/* But otherwise allow extra data: */ /* But otherwise allow extra data: */
@ -1506,34 +1508,34 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
* keep going. * keep going.
*/ */
png_chunk_warning(png_ptr, png_chunk_warning(png_ptr,
"extra compressed data"); "extra compressed data");
} }
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
finished = 1; finished = 1;
# ifdef PNG_sRGB_SUPPORTED # if defined(PNG_sRGB_SUPPORTED) && PNG_sRGB_PROFILE_CHECKS >= 0
/* Check for a match against sRGB */ /* Check for a match against sRGB */
png_icc_set_sRGB(png_ptr, png_icc_set_sRGB(png_ptr,
&png_ptr->colorspace, profile, &png_ptr->colorspace, profile,
png_ptr->zstream.adler); png_ptr->zstream.adler);
# endif # endif
/* Steal the profile for info_ptr. */ /* Steal the profile for info_ptr. */
if (info_ptr != NULL) if (info_ptr != NULL)
{ {
png_free_data(png_ptr, info_ptr, png_free_data(png_ptr, info_ptr,
PNG_FREE_ICCP, 0); PNG_FREE_ICCP, 0);
info_ptr->iccp_name = png_voidcast(char*, info_ptr->iccp_name = png_voidcast(char*,
png_malloc_base(png_ptr, png_malloc_base(png_ptr,
keyword_length+1)); keyword_length+1));
if (info_ptr->iccp_name != NULL) if (info_ptr->iccp_name != NULL)
{ {
memcpy(info_ptr->iccp_name, keyword, memcpy(info_ptr->iccp_name, keyword,
keyword_length+1); keyword_length+1);
info_ptr->iccp_proflen = info_ptr->iccp_proflen =
profile_length; profile_length;
info_ptr->iccp_profile = profile; info_ptr->iccp_profile = profile;
png_ptr->read_buffer = NULL; /*steal*/ png_ptr->read_buffer = NULL; /*steal*/
info_ptr->free_me |= PNG_FREE_ICCP; info_ptr->free_me |= PNG_FREE_ICCP;
@ -2270,7 +2272,7 @@ png_handle_pCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
} }
png_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams, png_set_pCAL(png_ptr, info_ptr, (png_charp)buffer, X0, X1, type, nparams,
(png_charp)units, params); (png_charp)units, params);
png_free(png_ptr, params); png_free(png_ptr, params);
} }
@ -2313,7 +2315,7 @@ png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
} }
png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)", png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)",
length + 1); length + 1);
buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/); buffer = png_read_buffer(png_ptr, length+1, 2/*silent*/);
@ -2365,7 +2367,7 @@ png_handle_sCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
else else
/* This is the (only) success case. */ /* This is the (only) success case. */
png_set_sCAL_s(png_ptr, info_ptr, buffer[0], png_set_sCAL_s(png_ptr, info_ptr, buffer[0],
(png_charp)buffer+1, (png_charp)buffer+heighti); (png_charp)buffer+1, (png_charp)buffer+heighti);
} }
} }
#endif #endif
@ -2465,8 +2467,8 @@ png_handle_tEXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
if (buffer == NULL) if (buffer == NULL)
{ {
png_chunk_benign_error(png_ptr, "out of memory"); png_chunk_benign_error(png_ptr, "out of memory");
return; return;
} }
png_crc_read(png_ptr, buffer, length); png_crc_read(png_ptr, buffer, length);
@ -2573,7 +2575,7 @@ png_handle_zTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
* and text chunks. * and text chunks.
*/ */
if (png_decompress_chunk(png_ptr, length, keyword_length+2, if (png_decompress_chunk(png_ptr, length, keyword_length+2,
&uncompressed_length, 1/*terminate*/) == Z_STREAM_END) &uncompressed_length, 1/*terminate*/) == Z_STREAM_END)
{ {
png_text text; png_text text;
@ -2713,7 +2715,7 @@ png_handle_iTXt(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
* iCCP and text chunks. * iCCP and text chunks.
*/ */
if (png_decompress_chunk(png_ptr, length, prefix_length, if (png_decompress_chunk(png_ptr, length, prefix_length,
&uncompressed_length, 1/*terminate*/) == Z_STREAM_END) &uncompressed_length, 1/*terminate*/) == Z_STREAM_END)
buffer = png_ptr->read_buffer; buffer = png_ptr->read_buffer;
else else
@ -2793,7 +2795,7 @@ png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length)
{ {
/* Do a 'warn' here - it is handled below. */ /* Do a 'warn' here - it is handled below. */
png_ptr->unknown_chunk.data = png_voidcast(png_bytep, png_ptr->unknown_chunk.data = png_voidcast(png_bytep,
png_malloc_warn(png_ptr, length)); png_malloc_warn(png_ptr, length));
} }
} }
@ -2818,7 +2820,7 @@ png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length)
/* Handle an unknown, or known but disabled, chunk */ /* Handle an unknown, or known but disabled, chunk */
void /* PRIVATE */ void /* PRIVATE */
png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr, png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
png_uint_32 length, int keep) png_uint_32 length, int keep)
{ {
int handled = 0; /* the chunk was handled */ int handled = 0; /* the chunk was handled */
@ -2856,7 +2858,7 @@ png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
{ {
/* Callback to user unknown chunk handler */ /* Callback to user unknown chunk handler */
int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr, int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr,
&png_ptr->unknown_chunk); &png_ptr->unknown_chunk);
/* ret is: /* ret is:
* negative: An error occurred; png_chunk_error will be called. * negative: An error occurred; png_chunk_error will be called.
@ -2890,9 +2892,9 @@ png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
{ {
png_chunk_warning(png_ptr, "Saving unknown chunk:"); png_chunk_warning(png_ptr, "Saving unknown chunk:");
png_app_warning(png_ptr, png_app_warning(png_ptr,
"forcing save of an unhandled chunk;" "forcing save of an unhandled chunk;"
" please call png_set_keep_unknown_chunks"); " please call png_set_keep_unknown_chunks");
/* with keep = PNG_HANDLE_CHUNK_IF_SAFE */ /* with keep = PNG_HANDLE_CHUNK_IF_SAFE */
} }
# endif # endif
keep = PNG_HANDLE_CHUNK_IF_SAFE; keep = PNG_HANDLE_CHUNK_IF_SAFE;
@ -2985,7 +2987,7 @@ png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
* out; store the chunk. * out; store the chunk.
*/ */
png_set_unknown_chunks(png_ptr, info_ptr, png_set_unknown_chunks(png_ptr, info_ptr,
&png_ptr->unknown_chunk, 1); &png_ptr->unknown_chunk, 1);
handled = 1; handled = 1;
# ifdef PNG_USER_LIMITS_SUPPORTED # ifdef PNG_USER_LIMITS_SUPPORTED
break; break;
@ -3418,8 +3420,8 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
/* Everything is aligned for png_uint_16 copies, but try for /* Everything is aligned for png_uint_16 copies, but try for
* png_uint_32 first. * png_uint_32 first.
*/ */
if (png_isaligned(dp, png_uint_32) != 0 && if (png_isaligned(dp, png_uint_32) &&
png_isaligned(sp, png_uint_32) != 0 && png_isaligned(sp, png_uint_32) &&
bytes_to_copy % (sizeof (png_uint_32)) == 0 && bytes_to_copy % (sizeof (png_uint_32)) == 0 &&
bytes_to_jump % (sizeof (png_uint_32)) == 0) bytes_to_jump % (sizeof (png_uint_32)) == 0)
{ {
@ -3539,7 +3541,7 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
#ifdef PNG_READ_INTERLACING_SUPPORTED #ifdef PNG_READ_INTERLACING_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass, png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
png_uint_32 transformations /* Because these may affect the byte layout */) png_uint_32 transformations /* Because these may affect the byte layout */)
{ {
/* 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 */
@ -3783,7 +3785,7 @@ png_do_read_interlace(png_row_infop row_info, png_bytep row, int pass,
static void static void
png_read_filter_row_sub(png_row_infop row_info, png_bytep row, png_read_filter_row_sub(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row) png_const_bytep prev_row)
{ {
png_size_t i; png_size_t i;
png_size_t istop = row_info->rowbytes; png_size_t istop = row_info->rowbytes;
@ -3801,7 +3803,7 @@ png_read_filter_row_sub(png_row_infop row_info, png_bytep row,
static void static void
png_read_filter_row_up(png_row_infop row_info, png_bytep row, png_read_filter_row_up(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row) png_const_bytep prev_row)
{ {
png_size_t i; png_size_t i;
png_size_t istop = row_info->rowbytes; png_size_t istop = row_info->rowbytes;
@ -3817,7 +3819,7 @@ png_read_filter_row_up(png_row_infop row_info, png_bytep row,
static void static void
png_read_filter_row_avg(png_row_infop row_info, png_bytep row, png_read_filter_row_avg(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row) png_const_bytep prev_row)
{ {
png_size_t i; png_size_t i;
png_bytep rp = row; png_bytep rp = row;
@ -3844,7 +3846,7 @@ png_read_filter_row_avg(png_row_infop row_info, png_bytep row,
static void static void
png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row, png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row) png_const_bytep prev_row)
{ {
png_bytep rp_end = row + row_info->rowbytes; png_bytep rp_end = row + row_info->rowbytes;
int a, c; int a, c;
@ -3892,7 +3894,7 @@ png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row,
static void static void
png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row, png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row,
png_const_bytep prev_row) png_const_bytep prev_row)
{ {
int bpp = (row_info->pixel_depth + 7) >> 3; int bpp = (row_info->pixel_depth + 7) >> 3;
png_bytep rp_end = row + bpp; png_bytep rp_end = row + bpp;
@ -3977,7 +3979,7 @@ png_init_filter_functions(png_structrp pp)
void /* PRIVATE */ void /* PRIVATE */
png_read_filter_row(png_structrp pp, png_row_infop row_info, png_bytep row, png_read_filter_row(png_structrp pp, png_row_infop row_info, png_bytep row,
png_const_bytep prev_row, int filter) png_const_bytep prev_row, int filter)
{ {
/* OPTIMIZATION: DO NOT MODIFY THIS FUNCTION, instead #define /* OPTIMIZATION: DO NOT MODIFY THIS FUNCTION, instead #define
* PNG_FILTER_OPTIMIZATIONS to a function that overrides the generic * PNG_FILTER_OPTIMIZATIONS to a function that overrides the generic
@ -3995,7 +3997,7 @@ png_read_filter_row(png_structrp pp, png_row_infop row_info, png_bytep row,
#ifdef PNG_SEQUENTIAL_READ_SUPPORTED #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_read_IDAT_data(png_structrp png_ptr, png_bytep output, png_read_IDAT_data(png_structrp png_ptr, png_bytep output,
png_alloc_size_t avail_out) png_alloc_size_t avail_out)
{ {
/* Loop reading IDATs and decompressing the result into output[avail_out] */ /* Loop reading IDATs and decompressing the result into output[avail_out] */
png_ptr->zstream.next_out = output; png_ptr->zstream.next_out = output;
@ -4447,42 +4449,42 @@ defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
if (row_bytes + 48 > png_ptr->old_big_row_buf_size) if (row_bytes + 48 > 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_free(png_ptr, png_ptr->big_prev_row); png_free(png_ptr, png_ptr->big_prev_row);
if (png_ptr->interlaced != 0) if (png_ptr->interlaced != 0)
png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr, png_ptr->big_row_buf = (png_bytep)png_calloc(png_ptr,
row_bytes + 48); row_bytes + 48);
else else
png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48); png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48); png_ptr->big_prev_row = (png_bytep)png_malloc(png_ptr, row_bytes + 48);
#ifdef PNG_ALIGNED_MEMORY_SUPPORTED #ifdef PNG_ALIGNED_MEMORY_SUPPORTED
/* Use 16-byte aligned memory for row_buf with at least 16 bytes /* Use 16-byte aligned memory for row_buf with at least 16 bytes
* of padding before and after row_buf; treat prev_row similarly. * of padding before and after row_buf; treat prev_row similarly.
* NOTE: the alignment is to the start of the pixels, one beyond the start * NOTE: the alignment is to the start of the pixels, one beyond the start
* of the buffer, because of the filter byte. Prior to libpng 1.5.6 this * of the buffer, because of the filter byte. Prior to libpng 1.5.6 this
* was incorrect; the filter byte was aligned, which had the exact * was incorrect; the filter byte was aligned, which had the exact
* opposite effect of that intended. * opposite effect of that intended.
*/ */
{ {
png_bytep temp = png_ptr->big_row_buf + 32; png_bytep temp = png_ptr->big_row_buf + 32;
int extra = (int)((temp - (png_bytep)0) & 0x0f); int extra = (int)((temp - (png_bytep)0) & 0x0f);
png_ptr->row_buf = temp - extra - 1/*filter byte*/; png_ptr->row_buf = temp - extra - 1/*filter byte*/;
temp = png_ptr->big_prev_row + 32; temp = png_ptr->big_prev_row + 32;
extra = (int)((temp - (png_bytep)0) & 0x0f); extra = (int)((temp - (png_bytep)0) & 0x0f);
png_ptr->prev_row = temp - extra - 1/*filter byte*/; png_ptr->prev_row = temp - extra - 1/*filter byte*/;
} }
#else #else
/* Use 31 bytes of padding before and 17 bytes after row_buf. */ /* Use 31 bytes of padding before and 17 bytes after row_buf. */
png_ptr->row_buf = png_ptr->big_row_buf + 31; png_ptr->row_buf = png_ptr->big_row_buf + 31;
png_ptr->prev_row = png_ptr->big_prev_row + 31; png_ptr->prev_row = png_ptr->big_prev_row + 31;
#endif #endif
png_ptr->old_big_row_buf_size = row_bytes + 48; png_ptr->old_big_row_buf_size = row_bytes + 48;
} }
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K

188
thirdparty/libpng/pngset.c vendored
View File

@ -1,8 +1,8 @@
/* pngset.c - storage of image information into info struct /* pngset.c - storage of image information into info struct
* *
* Last changed in libpng 1.6.21 [January 15, 2016] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2016 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.)
* *
@ -104,14 +104,14 @@ png_set_cHRM(png_const_structrp png_ptr, png_inforp info_ptr,
double green_x, double green_y, double blue_x, double blue_y) double green_x, double green_y, double blue_x, double blue_y)
{ {
png_set_cHRM_fixed(png_ptr, info_ptr, png_set_cHRM_fixed(png_ptr, info_ptr,
png_fixed(png_ptr, white_x, "cHRM White X"), png_fixed(png_ptr, white_x, "cHRM White X"),
png_fixed(png_ptr, white_y, "cHRM White Y"), png_fixed(png_ptr, white_y, "cHRM White Y"),
png_fixed(png_ptr, red_x, "cHRM Red X"), png_fixed(png_ptr, red_x, "cHRM Red X"),
png_fixed(png_ptr, red_y, "cHRM Red Y"), png_fixed(png_ptr, red_y, "cHRM Red Y"),
png_fixed(png_ptr, green_x, "cHRM Green X"), png_fixed(png_ptr, green_x, "cHRM Green X"),
png_fixed(png_ptr, green_y, "cHRM Green Y"), png_fixed(png_ptr, green_y, "cHRM Green Y"),
png_fixed(png_ptr, blue_x, "cHRM Blue X"), png_fixed(png_ptr, blue_x, "cHRM Blue X"),
png_fixed(png_ptr, blue_y, "cHRM Blue Y")); png_fixed(png_ptr, blue_y, "cHRM Blue Y"));
} }
void PNGAPI void PNGAPI
@ -120,15 +120,15 @@ png_set_cHRM_XYZ(png_const_structrp png_ptr, png_inforp info_ptr, double red_X,
double blue_X, double blue_Y, double blue_Z) double blue_X, double blue_Y, double blue_Z)
{ {
png_set_cHRM_XYZ_fixed(png_ptr, info_ptr, png_set_cHRM_XYZ_fixed(png_ptr, info_ptr,
png_fixed(png_ptr, red_X, "cHRM Red X"), png_fixed(png_ptr, red_X, "cHRM Red X"),
png_fixed(png_ptr, red_Y, "cHRM Red Y"), png_fixed(png_ptr, red_Y, "cHRM Red Y"),
png_fixed(png_ptr, red_Z, "cHRM Red Z"), png_fixed(png_ptr, red_Z, "cHRM Red Z"),
png_fixed(png_ptr, green_X, "cHRM Green X"), png_fixed(png_ptr, green_X, "cHRM Green X"),
png_fixed(png_ptr, green_Y, "cHRM Green Y"), png_fixed(png_ptr, green_Y, "cHRM Green Y"),
png_fixed(png_ptr, green_Z, "cHRM Green Z"), png_fixed(png_ptr, green_Z, "cHRM Green Z"),
png_fixed(png_ptr, blue_X, "cHRM Blue X"), png_fixed(png_ptr, blue_X, "cHRM Blue X"),
png_fixed(png_ptr, blue_Y, "cHRM Blue Y"), png_fixed(png_ptr, blue_Y, "cHRM Blue Y"),
png_fixed(png_ptr, blue_Z, "cHRM Blue Z")); png_fixed(png_ptr, blue_Z, "cHRM Blue Z"));
} }
# endif /* FLOATING_POINT */ # endif /* FLOATING_POINT */
@ -316,10 +316,10 @@ png_set_pCAL(png_const_structrp png_ptr, png_inforp info_ptr,
length = strlen(units) + 1; length = strlen(units) + 1;
png_debug1(3, "allocating units for info (%lu bytes)", png_debug1(3, "allocating units for info (%lu bytes)",
(unsigned long)length); (unsigned long)length);
info_ptr->pcal_units = png_voidcast(png_charp, info_ptr->pcal_units = png_voidcast(png_charp,
png_malloc_warn(png_ptr, length)); png_malloc_warn(png_ptr, length));
if (info_ptr->pcal_units == NULL) if (info_ptr->pcal_units == NULL)
{ {
@ -398,7 +398,7 @@ png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr,
png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw); png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthw);
info_ptr->scal_s_width = png_voidcast(png_charp, info_ptr->scal_s_width = png_voidcast(png_charp,
png_malloc_warn(png_ptr, lengthw)); png_malloc_warn(png_ptr, lengthw));
if (info_ptr->scal_s_width == NULL) if (info_ptr->scal_s_width == NULL)
{ {
@ -414,7 +414,7 @@ png_set_sCAL_s(png_const_structrp png_ptr, png_inforp info_ptr,
png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh); png_debug1(3, "allocating unit for info (%u bytes)", (unsigned int)lengthh);
info_ptr->scal_s_height = png_voidcast(png_charp, info_ptr->scal_s_height = png_voidcast(png_charp,
png_malloc_warn(png_ptr, lengthh)); png_malloc_warn(png_ptr, lengthh));
if (info_ptr->scal_s_height == NULL) if (info_ptr->scal_s_height == NULL)
{ {
@ -453,9 +453,9 @@ png_set_sCAL(png_const_structrp png_ptr, png_inforp info_ptr, int unit,
char sheight[PNG_sCAL_MAX_DIGITS+1]; char sheight[PNG_sCAL_MAX_DIGITS+1];
png_ascii_from_fp(png_ptr, swidth, (sizeof swidth), width, png_ascii_from_fp(png_ptr, swidth, (sizeof swidth), width,
PNG_sCAL_PRECISION); PNG_sCAL_PRECISION);
png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height, png_ascii_from_fp(png_ptr, sheight, (sizeof sheight), height,
PNG_sCAL_PRECISION); PNG_sCAL_PRECISION);
png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight); png_set_sCAL_s(png_ptr, info_ptr, unit, swidth, sheight);
} }
@ -648,7 +648,7 @@ png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
*/ */
{ {
int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name, int result = png_colorspace_set_ICC(png_ptr, &info_ptr->colorspace, name,
proflen, profile, info_ptr->color_type); proflen, profile, info_ptr->color_type);
png_colorspace_sync_info(png_ptr, info_ptr); png_colorspace_sync_info(png_ptr, info_ptr);
@ -673,7 +673,7 @@ png_set_iCCP(png_const_structrp png_ptr, png_inforp info_ptr,
memcpy(new_iccp_name, name, length); memcpy(new_iccp_name, name, length);
new_iccp_profile = png_voidcast(png_bytep, new_iccp_profile = png_voidcast(png_bytep,
png_malloc_warn(png_ptr, proflen)); png_malloc_warn(png_ptr, proflen));
if (new_iccp_profile == NULL) if (new_iccp_profile == NULL)
{ {
@ -748,14 +748,14 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
* the overflow checks. * the overflow checks.
*/ */
new_text = png_voidcast(png_textp,png_realloc_array(png_ptr, new_text = png_voidcast(png_textp,png_realloc_array(png_ptr,
info_ptr->text, old_num_text, max_text-old_num_text, info_ptr->text, old_num_text, max_text-old_num_text,
sizeof *new_text)); sizeof *new_text));
} }
if (new_text == NULL) if (new_text == NULL)
{ {
png_chunk_report(png_ptr, "too many text chunks", png_chunk_report(png_ptr, "too many text chunks",
PNG_CHUNK_WRITE_ERROR); PNG_CHUNK_WRITE_ERROR);
return 1; return 1;
} }
@ -783,7 +783,7 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST) text_ptr[i].compression >= PNG_TEXT_COMPRESSION_LAST)
{ {
png_chunk_report(png_ptr, "text compression mode is out of range", png_chunk_report(png_ptr, "text compression mode is out of range",
PNG_CHUNK_WRITE_ERROR); PNG_CHUNK_WRITE_ERROR);
continue; continue;
} }
@ -815,7 +815,7 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
# else /* iTXt */ # else /* iTXt */
{ {
png_chunk_report(png_ptr, "iTXt chunk not supported", png_chunk_report(png_ptr, "iTXt chunk not supported",
PNG_CHUNK_WRITE_ERROR); PNG_CHUNK_WRITE_ERROR);
continue; continue;
} }
# endif # endif
@ -844,7 +844,7 @@ png_set_text_2(png_const_structrp png_ptr, png_inforp info_ptr,
if (textp->key == NULL) if (textp->key == NULL)
{ {
png_chunk_report(png_ptr, "text chunk: out of memory", png_chunk_report(png_ptr, "text chunk: out of memory",
PNG_CHUNK_WRITE_ERROR); PNG_CHUNK_WRITE_ERROR);
return 1; return 1;
} }
@ -952,12 +952,14 @@ png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr,
png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0); png_free_data(png_ptr, info_ptr, PNG_FREE_TRNS, 0);
/* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
png_ptr->trans_alpha = info_ptr->trans_alpha = png_voidcast(png_bytep,
png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH) if (num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH)
{
/* Changed from num_trans to PNG_MAX_PALETTE_LENGTH in version 1.2.1 */
info_ptr->trans_alpha = png_voidcast(png_bytep,
png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH));
memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans); memcpy(info_ptr->trans_alpha, trans_alpha, (png_size_t)num_trans);
}
png_ptr->trans_alpha = info_ptr->trans_alpha;
} }
if (trans_color != NULL) if (trans_color != NULL)
@ -974,7 +976,7 @@ png_set_tRNS(png_structrp png_ptr, png_inforp info_ptr,
trans_color->green > sample_max || trans_color->green > sample_max ||
trans_color->blue > sample_max))) trans_color->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");
} }
#endif #endif
@ -1016,8 +1018,8 @@ png_set_sPLT(png_const_structrp png_ptr,
* overflows. Notice that the parameters are (int) and (size_t) * overflows. Notice that the parameters are (int) and (size_t)
*/ */
np = png_voidcast(png_sPLT_tp,png_realloc_array(png_ptr, np = png_voidcast(png_sPLT_tp,png_realloc_array(png_ptr,
info_ptr->splt_palettes, info_ptr->splt_palettes_num, nentries, info_ptr->splt_palettes, info_ptr->splt_palettes_num, nentries,
sizeof *np)); sizeof *np));
if (np == NULL) if (np == NULL)
{ {
@ -1078,7 +1080,7 @@ png_set_sPLT(png_const_structrp png_ptr,
* checked it when doing the allocation. * checked it when doing the allocation.
*/ */
memcpy(np->entries, entries->entries, memcpy(np->entries, entries->entries,
entries->nentries * sizeof (png_sPLT_entry)); entries->nentries * sizeof (png_sPLT_entry));
/* Note that 'continue' skips the advance of the out pointer and out /* Note that 'continue' skips the advance of the out pointer and out
* count, so an invalid entry is not added. * count, so an invalid entry is not added.
@ -1108,10 +1110,10 @@ check_location(png_const_structrp png_ptr, int location)
{ {
/* Write struct, so unknown chunks come from the app */ /* Write struct, so unknown chunks come from the app */
png_app_warning(png_ptr, png_app_warning(png_ptr,
"png_set_unknown_chunks now expects a valid location"); "png_set_unknown_chunks now expects a valid location");
/* Use the old behavior */ /* Use the old behavior */
location = (png_byte)(png_ptr->mode & location = (png_byte)(png_ptr->mode &
(PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT)); (PNG_HAVE_IHDR|PNG_HAVE_PLTE|PNG_AFTER_IDAT));
} }
/* This need not be an internal error - if the app calls /* This need not be an internal error - if the app calls
@ -1134,7 +1136,7 @@ check_location(png_const_structrp png_ptr, int location)
void PNGAPI void PNGAPI
png_set_unknown_chunks(png_const_structrp png_ptr, png_set_unknown_chunks(png_const_structrp png_ptr,
png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns) png_inforp info_ptr, png_const_unknown_chunkp unknowns, int num_unknowns)
{ {
png_unknown_chunkp np; png_unknown_chunkp np;
@ -1173,13 +1175,13 @@ png_set_unknown_chunks(png_const_structrp png_ptr,
* appropriate to read or write. * appropriate to read or write.
*/ */
np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr, np = png_voidcast(png_unknown_chunkp, png_realloc_array(png_ptr,
info_ptr->unknown_chunks, info_ptr->unknown_chunks_num, num_unknowns, info_ptr->unknown_chunks, info_ptr->unknown_chunks_num, num_unknowns,
sizeof *np)); sizeof *np));
if (np == NULL) if (np == NULL)
{ {
png_chunk_report(png_ptr, "too many unknown chunks", png_chunk_report(png_ptr, "too many unknown chunks",
PNG_CHUNK_WRITE_ERROR); PNG_CHUNK_WRITE_ERROR);
return; return;
} }
@ -1208,12 +1210,12 @@ png_set_unknown_chunks(png_const_structrp png_ptr,
else else
{ {
np->data = png_voidcast(png_bytep, np->data = png_voidcast(png_bytep,
png_malloc_base(png_ptr, unknowns->size)); png_malloc_base(png_ptr, unknowns->size));
if (np->data == NULL) if (np->data == NULL)
{ {
png_chunk_report(png_ptr, "unknown chunk: out of memory", png_chunk_report(png_ptr, "unknown chunk: out of memory",
PNG_CHUNK_WRITE_ERROR); PNG_CHUNK_WRITE_ERROR);
/* But just skip storing the unknown chunk */ /* But just skip storing the unknown chunk */
continue; continue;
} }
@ -1420,7 +1422,7 @@ png_set_keep_unknown_chunks(png_structrp png_ptr, int keep,
for (i=0; i<num_chunks; ++i) for (i=0; i<num_chunks; ++i)
{ {
old_num_chunks = add_one_chunk(new_list, old_num_chunks, old_num_chunks = add_one_chunk(new_list, old_num_chunks,
chunk_list+5*i, keep); chunk_list+5*i, keep);
} }
/* Now remove any spurious 'default' entries. */ /* Now remove any spurious 'default' entries. */
@ -1500,60 +1502,60 @@ png_set_rows(png_const_structrp png_ptr, png_inforp info_ptr,
void PNGAPI void PNGAPI
png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size) png_set_compression_buffer_size(png_structrp png_ptr, png_size_t size)
{ {
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
if (size == 0 || size > PNG_UINT_31_MAX) if (size == 0 || size > PNG_UINT_31_MAX)
png_error(png_ptr, "invalid compression buffer size"); png_error(png_ptr, "invalid compression buffer size");
# ifdef PNG_SEQUENTIAL_READ_SUPPORTED # ifdef PNG_SEQUENTIAL_READ_SUPPORTED
if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0) if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0)
{ {
png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */ png_ptr->IDAT_read_size = (png_uint_32)size; /* checked above */
return; return;
} }
# endif # endif
# ifdef PNG_WRITE_SUPPORTED # ifdef PNG_WRITE_SUPPORTED
if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0) if ((png_ptr->mode & PNG_IS_READ_STRUCT) == 0)
{
if (png_ptr->zowner != 0)
{ {
if (png_ptr->zowner != 0) png_warning(png_ptr,
{ "Compression buffer size cannot be changed because it is in use");
png_warning(png_ptr,
"Compression buffer size cannot be changed because it is in use");
return; return;
} }
#ifndef __COVERITY__ #ifndef __COVERITY__
/* Some compilers complain that this is always false. However, it /* Some compilers complain that this is always false. However, it
* can be true when integer overflow happens. * can be true when integer overflow happens.
*/ */
if (size > ZLIB_IO_MAX) if (size > ZLIB_IO_MAX)
{ {
png_warning(png_ptr, png_warning(png_ptr,
"Compression buffer size limited to system maximum"); "Compression buffer size limited to system maximum");
size = ZLIB_IO_MAX; /* must fit */ size = ZLIB_IO_MAX; /* must fit */
} }
#endif #endif
if (size < 6) if (size < 6)
{ {
/* Deflate will potentially go into an infinite loop on a SYNC_FLUSH /* Deflate will potentially go into an infinite loop on a SYNC_FLUSH
* if this is permitted. * if this is permitted.
*/ */
png_warning(png_ptr, png_warning(png_ptr,
"Compression buffer size cannot be reduced below 6"); "Compression buffer size cannot be reduced below 6");
return; return;
}
if (png_ptr->zbuffer_size != size)
{
png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
png_ptr->zbuffer_size = (uInt)size;
}
} }
if (png_ptr->zbuffer_size != size)
{
png_free_buffer_list(png_ptr, &png_ptr->zbuffer_list);
png_ptr->zbuffer_size = (uInt)size;
}
}
# endif # endif
} }
@ -1660,7 +1662,9 @@ png_set_check_for_invalid_index(png_structrp png_ptr, int allowed)
png_uint_32 /* PRIVATE */ png_uint_32 /* PRIVATE */
png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key) png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
{ {
#ifdef PNG_WARNINGS_SUPPORTED
png_const_charp orig_key = key; png_const_charp orig_key = key;
#endif
png_uint_32 key_len = 0; png_uint_32 key_len = 0;
int bad_character = 0; int bad_character = 0;
int space = 1; int space = 1;
@ -1723,7 +1727,9 @@ png_check_keyword(png_structrp png_ptr, png_const_charp key, png_bytep new_key)
png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'"); png_formatted_warning(png_ptr, p, "keyword \"@1\": bad character '0x@2'");
} }
#endif /* WARNINGS */ #else /* !WARNINGS */
PNG_UNUSED(png_ptr)
#endif /* !WARNINGS */
return key_len; return key_len;
} }

6
thirdparty/libpng/pngstruct.h vendored
View File

@ -1,8 +1,8 @@
/* pngstruct.h - header file for PNG reference library /* pngstruct.h - header file for PNG reference library
* *
* Last changed in libpng 1.6.18 [July 23, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -249,7 +249,7 @@ struct png_struct_def
png_byte filter; /* file filter type (always 0) */ png_byte filter; /* file filter type (always 0) */
png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */
png_byte pass; /* current interlace pass (0 - 6) */ png_byte pass; /* current interlace pass (0 - 6) */
png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ png_byte do_filter; /* row filter flags (see PNG_FILTER_ in png.h ) */
png_byte color_type; /* color type of file */ png_byte color_type; /* color type of file */
png_byte bit_depth; /* bit depth of file */ png_byte bit_depth; /* bit depth of file */
png_byte usr_bit_depth; /* bit depth of users row: write only */ png_byte usr_bit_depth; /* bit depth of users row: write only */

11
thirdparty/libpng/pngtrans.c vendored
View File

@ -1,8 +1,8 @@
/* 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.6.18 [July 23, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -172,13 +172,14 @@ png_set_filler(png_structrp png_ptr, png_uint_32 filler, int filler_loc)
* size! * size!
*/ */
png_app_error(png_ptr, png_app_error(png_ptr,
"png_set_filler is invalid for low bit depth gray output"); "png_set_filler is invalid for"
" low bit depth gray output");
return; return;
} }
default: default:
png_app_error(png_ptr, png_app_error(png_ptr,
"png_set_filler: inappropriate color type"); "png_set_filler: inappropriate color type");
return; return;
} }
# else # else
@ -797,7 +798,7 @@ png_set_user_transform_info(png_structrp png_ptr, png_voidp
(png_ptr->flags & PNG_FLAG_ROW_INIT) != 0) (png_ptr->flags & PNG_FLAG_ROW_INIT) != 0)
{ {
png_app_error(png_ptr, png_app_error(png_ptr,
"info change after png_start_read_image or png_read_update_info"); "info change after png_start_read_image or png_read_update_info");
return; return;
} }
#endif #endif

6
thirdparty/libpng/pngwio.c vendored
View File

@ -1,8 +1,8 @@
/* pngwio.c - functions for data output /* pngwio.c - functions for data output
* *
* Last changed in libpng 1.6.15 [November 20, 2014] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2014 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2014,2016 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.)
* *
@ -35,7 +35,7 @@ png_write_data(png_structrp png_ptr, png_const_bytep data, png_size_t length)
/* NOTE: write_data_fn must not change the buffer! */ /* NOTE: write_data_fn must not change the buffer! */
if (png_ptr->write_data_fn != NULL ) if (png_ptr->write_data_fn != NULL )
(*(png_ptr->write_data_fn))(png_ptr, png_constcast(png_bytep,data), (*(png_ptr->write_data_fn))(png_ptr, png_constcast(png_bytep,data),
length); length);
else else
png_error(png_ptr, "Call to NULL write function"); png_error(png_ptr, "Call to NULL write function");

251
thirdparty/libpng/pngwrite.c vendored
View File

@ -1,8 +1,8 @@
/* pngwrite.c - general routines to write a PNG file /* pngwrite.c - general routines to write a PNG file
* *
* Last changed in libpng 1.6.19 [November 12, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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,9 +12,9 @@
*/ */
#include "pngpriv.h" #include "pngpriv.h"
#if defined(PNG_SIMPLIFIED_WRITE_SUPPORTED) && defined(PNG_STDIO_SUPPORTED) #ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
# include <errno.h> # include <errno.h>
#endif #endif /* SIMPLIFIED_WRITE_STDIO */
#ifdef PNG_WRITE_SUPPORTED #ifdef PNG_WRITE_SUPPORTED
@ -22,7 +22,7 @@
/* Write out all the unknown chunks for the current given location */ /* Write out all the unknown chunks for the current given location */
static void static void
write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr, write_unknown_chunks(png_structrp png_ptr, png_const_inforp info_ptr,
unsigned int where) unsigned int where)
{ {
if (info_ptr->unknown_chunks_num != 0) if (info_ptr->unknown_chunks_num != 0)
{ {
@ -148,11 +148,11 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
# ifdef PNG_WRITE_sRGB_SUPPORTED # ifdef PNG_WRITE_sRGB_SUPPORTED
if ((info_ptr->valid & PNG_INFO_sRGB) != 0) if ((info_ptr->valid & PNG_INFO_sRGB) != 0)
png_app_warning(png_ptr, png_app_warning(png_ptr,
"profile matches sRGB but writing iCCP instead"); "profile matches sRGB but writing iCCP instead");
# endif # endif
png_write_iCCP(png_ptr, info_ptr->iccp_name, png_write_iCCP(png_ptr, info_ptr->iccp_name,
info_ptr->iccp_profile); info_ptr->iccp_profile);
} }
# ifdef PNG_WRITE_sRGB_SUPPORTED # ifdef PNG_WRITE_sRGB_SUPPORTED
else else
@ -383,7 +383,7 @@ png_write_end(png_structrp png_ptr, png_inforp info_ptr)
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)
{ {
@ -693,7 +693,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
return; return;
png_debug2(1, "in png_write_row (row %u, pass %d)", png_debug2(1, "in png_write_row (row %u, 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)
@ -1069,7 +1069,7 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
* is not available so the filter can't be used. Just warn here. * is not available so the filter can't be used. Just warn here.
*/ */
png_app_warning(png_ptr, png_app_warning(png_ptr,
"png_set_filter: UP/AVG/PAETH cannot be added after start"); "png_set_filter: UP/AVG/PAETH cannot be added after start");
filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH); filters &= ~(PNG_FILTER_UP|PNG_FILTER_AVG|PNG_FILTER_PAETH);
} }
@ -1095,13 +1095,13 @@ png_set_filter(png_structrp png_ptr, int method, int filters)
if (png_ptr->try_row == NULL) if (png_ptr->try_row == NULL)
png_ptr->try_row = png_voidcast(png_bytep, png_ptr->try_row = png_voidcast(png_bytep,
png_malloc(png_ptr, buf_size)); png_malloc(png_ptr, buf_size));
if (num_filters > 1) if (num_filters > 1)
{ {
if (png_ptr->tst_row == NULL) if (png_ptr->tst_row == NULL)
png_ptr->tst_row = png_voidcast(png_bytep, png_ptr->tst_row = png_voidcast(png_bytep,
png_malloc(png_ptr, buf_size)); png_malloc(png_ptr, buf_size));
} }
} }
png_ptr->do_filter = (png_byte)filters; png_ptr->do_filter = (png_byte)filters;
@ -1452,7 +1452,6 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
#ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED #ifdef PNG_SIMPLIFIED_WRITE_SUPPORTED
# ifdef PNG_STDIO_SUPPORTED /* currently required for png_image_write_* */
/* Initialize the write structure - general purpose utility. */ /* Initialize the write structure - general purpose utility. */
static int static int
png_image_write_init(png_imagep image) png_image_write_init(png_imagep image)
@ -1504,6 +1503,10 @@ typedef struct
png_const_voidp first_row; png_const_voidp first_row;
ptrdiff_t row_bytes; ptrdiff_t row_bytes;
png_voidp local_row; png_voidp local_row;
/* Byte count for memory writing */
png_bytep memory;
png_alloc_size_t memory_bytes; /* not used for STDIO */
png_alloc_size_t output_bytes; /* running total */
} png_image_write_control; } png_image_write_control;
/* Write png_uint_16 input to a 16-bit PNG; the png_ptr has already been set to /* Write png_uint_16 input to a 16-bit PNG; the png_ptr has already been set to
@ -1625,7 +1628,7 @@ png_write_image_16bit(png_voidp argument)
static png_byte static png_byte
png_unpremultiply(png_uint_32 component, png_uint_32 alpha, png_unpremultiply(png_uint_32 component, png_uint_32 alpha,
png_uint_32 reciprocal/*from the above macro*/) png_uint_32 reciprocal/*from the above macro*/)
{ {
/* The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0 /* The following gives 1.0 for an alpha of 0, which is fine, otherwise if 0/0
* is represented as some other value there is more likely to be a * is represented as some other value there is more likely to be a
@ -1845,16 +1848,16 @@ png_image_set_PLTE(png_image_write_control *display)
if (channels >= 3) /* RGB */ if (channels >= 3) /* RGB */
{ {
palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)], palette[i].blue = png_unpremultiply(entry[afirst + (2 ^ bgr)],
alpha, reciprocal); alpha, reciprocal);
palette[i].green = png_unpremultiply(entry[afirst + 1], alpha, palette[i].green = png_unpremultiply(entry[afirst + 1], alpha,
reciprocal); reciprocal);
palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha, palette[i].red = png_unpremultiply(entry[afirst + bgr], alpha,
reciprocal); reciprocal);
} }
else /* gray */ else /* gray */
palette[i].blue = palette[i].red = palette[i].green = palette[i].blue = palette[i].red = palette[i].green =
png_unpremultiply(entry[afirst], alpha, reciprocal); png_unpremultiply(entry[afirst], alpha, reciprocal);
} }
} }
@ -1901,11 +1904,11 @@ png_image_set_PLTE(png_image_write_control *display)
# endif # endif
png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette, png_set_PLTE(image->opaque->png_ptr, image->opaque->info_ptr, palette,
entries); entries);
if (num_trans > 0) if (num_trans > 0)
png_set_tRNS(image->opaque->png_ptr, image->opaque->info_ptr, tRNS, png_set_tRNS(image->opaque->png_ptr, image->opaque->info_ptr, tRNS,
num_trans, NULL); num_trans, NULL);
image->colormap_entries = entries; image->colormap_entries = entries;
} }
@ -1914,7 +1917,7 @@ static int
png_image_write_main(png_voidp argument) png_image_write_main(png_voidp argument)
{ {
png_image_write_control *display = png_voidcast(png_image_write_control*, png_image_write_control *display = png_voidcast(png_image_write_control*,
argument); argument);
png_imagep image = display->image; png_imagep image = display->image;
png_structrp png_ptr = image->opaque->png_ptr; png_structrp png_ptr = image->opaque->png_ptr;
png_inforp info_ptr = image->opaque->info_ptr; png_inforp info_ptr = image->opaque->info_ptr;
@ -1931,9 +1934,43 @@ png_image_write_main(png_voidp argument)
png_set_benign_errors(png_ptr, 0/*error*/); png_set_benign_errors(png_ptr, 0/*error*/);
# endif # endif
/* Default the 'row_stride' parameter if required. */ /* Default the 'row_stride' parameter if required, also check the row stride
if (display->row_stride == 0) * and total image size to ensure that they are within the system limits.
display->row_stride = PNG_IMAGE_ROW_STRIDE(*image); */
{
const unsigned int channels = PNG_IMAGE_PIXEL_CHANNELS(image->format);
if (image->width <= 0x7FFFFFFFU/channels) /* no overflow */
{
png_uint_32 check;
const png_uint_32 png_row_stride = image->width * channels;
if (display->row_stride == 0)
display->row_stride = (png_int_32)/*SAFE*/png_row_stride;
if (display->row_stride < 0)
check = -display->row_stride;
else
check = display->row_stride;
if (check >= png_row_stride)
{
/* Now check for overflow of the image buffer calculation; this
* limits the whole image size to 32 bits for API compatibility with
* the current, 32-bit, PNG_IMAGE_BUFFER_SIZE macro.
*/
if (image->height > 0xFFFFFFFF/png_row_stride)
png_error(image->opaque->png_ptr, "memory image too large");
}
else
png_error(image->opaque->png_ptr, "supplied row stride too small");
}
else
png_error(image->opaque->png_ptr, "image row stride too large");
}
/* Set the required transforms then write the rows in the correct order. */ /* Set the required transforms then write the rows in the correct order. */
if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0) if ((format & PNG_FORMAT_FLAG_COLORMAP) != 0)
@ -1943,24 +1980,24 @@ png_image_write_main(png_voidp argument)
png_uint_32 entries = image->colormap_entries; png_uint_32 entries = image->colormap_entries;
png_set_IHDR(png_ptr, info_ptr, image->width, image->height, png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
entries > 16 ? 8 : (entries > 4 ? 4 : (entries > 2 ? 2 : 1)), entries > 16 ? 8 : (entries > 4 ? 4 : (entries > 2 ? 2 : 1)),
PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_image_set_PLTE(display); png_image_set_PLTE(display);
} }
else else
png_error(image->opaque->png_ptr, png_error(image->opaque->png_ptr,
"no color-map for color-mapped image"); "no color-map for color-mapped image");
} }
else else
png_set_IHDR(png_ptr, info_ptr, image->width, image->height, png_set_IHDR(png_ptr, info_ptr, image->width, image->height,
write_16bit ? 16 : 8, write_16bit ? 16 : 8,
((format & PNG_FORMAT_FLAG_COLOR) ? PNG_COLOR_MASK_COLOR : 0) + ((format & PNG_FORMAT_FLAG_COLOR) ? PNG_COLOR_MASK_COLOR : 0) +
((format & PNG_FORMAT_FLAG_ALPHA) ? PNG_COLOR_MASK_ALPHA : 0), ((format & PNG_FORMAT_FLAG_ALPHA) ? PNG_COLOR_MASK_ALPHA : 0),
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
/* Counter-intuitively the data transformations must be called *after* /* Counter-intuitively the data transformations must be called *after*
* png_write_info, not before as in the read code, but the 'set' functions * png_write_info, not before as in the read code, but the 'set' functions
@ -1975,11 +2012,11 @@ png_image_write_main(png_voidp argument)
if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0) if ((image->flags & PNG_IMAGE_FLAG_COLORSPACE_NOT_sRGB) == 0)
png_set_cHRM_fixed(png_ptr, info_ptr, png_set_cHRM_fixed(png_ptr, info_ptr,
/* color x y */ /* color x y */
/* white */ 31270, 32900, /* white */ 31270, 32900,
/* red */ 64000, 33000, /* red */ 64000, 33000,
/* green */ 30000, 60000, /* green */ 30000, 60000,
/* blue */ 15000, 6000 /* blue */ 15000, 6000
); );
} }
@ -2073,7 +2110,7 @@ png_image_write_main(png_voidp argument)
(colormap == 0 && display->convert_to_8bit != 0)) (colormap == 0 && display->convert_to_8bit != 0))
{ {
png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr, png_bytep row = png_voidcast(png_bytep, png_malloc(png_ptr,
png_get_rowbytes(png_ptr, info_ptr))); png_get_rowbytes(png_ptr, info_ptr)));
int result; int result;
display->local_row = row; display->local_row = row;
@ -2110,14 +2147,130 @@ png_image_write_main(png_voidp argument)
return 1; return 1;
} }
static void (PNGCBAPI
image_memory_write)(png_structp png_ptr, png_bytep/*const*/ data,
png_size_t size)
{
png_image_write_control *display = png_voidcast(png_image_write_control*,
png_ptr->io_ptr/*backdoor: png_get_io_ptr(png_ptr)*/);
const png_alloc_size_t ob = display->output_bytes;
/* Check for overflow; this should never happen: */
if (size <= ((png_alloc_size_t)-1) - ob)
{
/* I don't think libpng ever does this, but just in case: */
if (size > 0)
{
if (display->memory_bytes >= ob+size) /* writing */
memcpy(display->memory+ob, data, size);
/* Always update the size: */
display->output_bytes = ob+size;
}
}
else
png_error(png_ptr, "png_image_write_to_memory: PNG too big");
}
static void (PNGCBAPI
image_memory_flush)(png_structp png_ptr)
{
PNG_UNUSED(png_ptr)
}
static int
png_image_write_memory(png_voidp argument)
{
png_image_write_control *display = png_voidcast(png_image_write_control*,
argument);
/* The rest of the memory-specific init and write_main in an error protected
* environment. This case needs to use callbacks for the write operations
* since libpng has no built in support for writing to memory.
*/
png_set_write_fn(display->image->opaque->png_ptr, display/*io_ptr*/,
image_memory_write, image_memory_flush);
return png_image_write_main(display);
}
int PNGAPI
png_image_write_to_memory(png_imagep image, void *memory,
png_alloc_size_t * PNG_RESTRICT memory_bytes, int convert_to_8bit,
const void *buffer, png_int_32 row_stride, const void *colormap)
{
/* Write the image to the given buffer, or count the bytes if it is NULL */
if (image != NULL && image->version == PNG_IMAGE_VERSION)
{
if (memory_bytes != NULL && buffer != NULL)
{
/* This is to give the caller an easier error detection in the NULL
* case and guard against uninitialized variable problems:
*/
if (memory == NULL)
*memory_bytes = 0;
if (png_image_write_init(image) != 0)
{
png_image_write_control display;
int result;
memset(&display, 0, (sizeof display));
display.image = image;
display.buffer = buffer;
display.row_stride = row_stride;
display.colormap = colormap;
display.convert_to_8bit = convert_to_8bit;
display.memory = png_voidcast(png_bytep, memory);
display.memory_bytes = *memory_bytes;
display.output_bytes = 0;
result = png_safe_execute(image, png_image_write_memory, &display);
png_image_free(image);
/* write_memory returns true even if we ran out of buffer. */
if (result)
{
/* On out-of-buffer this function returns '0' but still updates
* memory_bytes:
*/
if (memory != NULL && display.output_bytes > *memory_bytes)
result = 0;
*memory_bytes = display.output_bytes;
}
return result;
}
else
return 0;
}
else
return png_image_error(image,
"png_image_write_to_memory: invalid argument");
}
else if (image != NULL)
return png_image_error(image,
"png_image_write_to_memory: incorrect PNG_IMAGE_VERSION");
else
return 0;
}
#ifdef PNG_SIMPLIFIED_WRITE_STDIO_SUPPORTED
int PNGAPI int PNGAPI
png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit, png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
const void *buffer, png_int_32 row_stride, const void *colormap) const void *buffer, png_int_32 row_stride, const void *colormap)
{ {
/* Write the image to the given (FILE*). */ /* Write the image to the given (FILE*). */
if (image != NULL && image->version == PNG_IMAGE_VERSION) if (image != NULL && image->version == PNG_IMAGE_VERSION)
{ {
if (file != NULL) if (file != NULL && buffer != NULL)
{ {
if (png_image_write_init(image) != 0) if (png_image_write_init(image) != 0)
{ {
@ -2148,12 +2301,12 @@ png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
else else
return png_image_error(image, return png_image_error(image,
"png_image_write_to_stdio: invalid argument"); "png_image_write_to_stdio: invalid argument");
} }
else if (image != NULL) else if (image != NULL)
return png_image_error(image, return png_image_error(image,
"png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION"); "png_image_write_to_stdio: incorrect PNG_IMAGE_VERSION");
else else
return 0; return 0;
@ -2161,20 +2314,20 @@ png_image_write_to_stdio(png_imagep image, FILE *file, int convert_to_8bit,
int PNGAPI int PNGAPI
png_image_write_to_file(png_imagep image, const char *file_name, png_image_write_to_file(png_imagep image, const char *file_name,
int convert_to_8bit, const void *buffer, png_int_32 row_stride, int convert_to_8bit, const void *buffer, png_int_32 row_stride,
const void *colormap) const void *colormap)
{ {
/* Write the image to the named file. */ /* Write the image to the named file. */
if (image != NULL && image->version == PNG_IMAGE_VERSION) if (image != NULL && image->version == PNG_IMAGE_VERSION)
{ {
if (file_name != NULL) if (file_name != NULL && buffer != NULL)
{ {
FILE *fp = fopen(file_name, "wb"); FILE *fp = fopen(file_name, "wb");
if (fp != NULL) if (fp != NULL)
{ {
if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer, if (png_image_write_to_stdio(image, fp, convert_to_8bit, buffer,
row_stride, colormap) != 0) row_stride, colormap) != 0)
{ {
int error; /* from fflush/fclose */ int error; /* from fflush/fclose */
@ -2215,16 +2368,16 @@ png_image_write_to_file(png_imagep image, const char *file_name,
else else
return png_image_error(image, return png_image_error(image,
"png_image_write_to_file: invalid argument"); "png_image_write_to_file: invalid argument");
} }
else if (image != NULL) else if (image != NULL)
return png_image_error(image, return png_image_error(image,
"png_image_write_to_file: incorrect PNG_IMAGE_VERSION"); "png_image_write_to_file: incorrect PNG_IMAGE_VERSION");
else else
return 0; return 0;
} }
# endif /* STDIO */ #endif /* SIMPLIFIED_WRITE_STDIO */
#endif /* SIMPLIFIED_WRITE */ #endif /* SIMPLIFIED_WRITE */
#endif /* WRITE */ #endif /* WRITE */

8
thirdparty/libpng/pngwtran.c vendored
View File

@ -1,8 +1,8 @@
/* 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.6.18 [July 23, 2015] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -525,7 +525,7 @@ png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
#ifdef PNG_WRITE_FILLER_SUPPORTED #ifdef PNG_WRITE_FILLER_SUPPORTED
if ((png_ptr->transformations & PNG_FILLER) != 0) if ((png_ptr->transformations & PNG_FILLER) != 0)
png_do_strip_channel(row_info, png_ptr->row_buf + 1, png_do_strip_channel(row_info, png_ptr->row_buf + 1,
!(png_ptr->flags & PNG_FLAG_FILLER_AFTER)); !(png_ptr->flags & PNG_FLAG_FILLER_AFTER));
#endif #endif
#ifdef PNG_WRITE_PACKSWAP_SUPPORTED #ifdef PNG_WRITE_PACKSWAP_SUPPORTED
@ -549,7 +549,7 @@ png_do_write_transformations(png_structrp png_ptr, png_row_infop row_info)
#ifdef PNG_WRITE_SHIFT_SUPPORTED #ifdef PNG_WRITE_SHIFT_SUPPORTED
if ((png_ptr->transformations & PNG_SHIFT) != 0) if ((png_ptr->transformations & PNG_SHIFT) != 0)
png_do_shift(row_info, png_ptr->row_buf + 1, png_do_shift(row_info, png_ptr->row_buf + 1,
&(png_ptr->shift)); &(png_ptr->shift));
#endif #endif
#ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED #ifdef PNG_WRITE_SWAP_ALPHA_SUPPORTED

228
thirdparty/libpng/pngwutil.c vendored
View File

@ -1,8 +1,8 @@
/* pngwutil.c - utilities to write a PNG file /* pngwutil.c - utilities to write a PNG file
* *
* Last changed in libpng 1.6.21 [January 15, 2016] * Last changed in libpng 1.6.24 [August 4, 2016]
* Copyright (c) 1998-2002,2004,2006-2015 Glenn Randers-Pehrson * Copyright (c) 1998-2002,2004,2006-2016 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.)
* *
@ -23,10 +23,10 @@
void PNGAPI void PNGAPI
png_save_uint_32(png_bytep buf, png_uint_32 i) png_save_uint_32(png_bytep buf, png_uint_32 i)
{ {
buf[0] = (png_byte)(i >> 24); buf[0] = (png_byte)((i >> 24) & 0xffU);
buf[1] = (png_byte)(i >> 16); buf[1] = (png_byte)((i >> 16) & 0xffU);
buf[2] = (png_byte)(i >> 8); buf[2] = (png_byte)((i >> 8) & 0xffU);
buf[3] = (png_byte)(i ); buf[3] = (png_byte)( i & 0xffU);
} }
/* Place a 16-bit number into a buffer in PNG byte order. /* Place a 16-bit number into a buffer in PNG byte order.
@ -36,8 +36,8 @@ png_save_uint_32(png_bytep buf, png_uint_32 i)
void PNGAPI void PNGAPI
png_save_uint_16(png_bytep buf, unsigned int i) png_save_uint_16(png_bytep buf, unsigned int i)
{ {
buf[0] = (png_byte)(i >> 8); buf[0] = (png_byte)((i >> 8) & 0xffU);
buf[1] = (png_byte)(i ); buf[1] = (png_byte)( i & 0xffU);
} }
#endif #endif
@ -59,7 +59,7 @@ png_write_sig(png_structrp png_ptr)
/* Write the rest of the 8 byte signature */ /* Write the rest of the 8 byte signature */
png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes], png_write_data(png_ptr, &png_signature[png_ptr->sig_bytes],
(png_size_t)(8 - png_ptr->sig_bytes)); (png_size_t)(8 - png_ptr->sig_bytes));
if (png_ptr->sig_bytes < 3) if (png_ptr->sig_bytes < 3)
png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE; png_ptr->mode |= PNG_HAVE_PNG_SIGNATURE;
@ -174,7 +174,7 @@ png_write_chunk_end(png_structrp png_ptr)
*/ */
static void static void
png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name, png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
png_const_bytep data, png_size_t length) png_const_bytep data, png_size_t length)
{ {
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;
@ -191,10 +191,10 @@ png_write_complete_chunk(png_structrp png_ptr, png_uint_32 chunk_name,
/* This is the API that calls the internal function above. */ /* This is the API that calls the internal function above. */
void PNGAPI void PNGAPI
png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string, png_write_chunk(png_structrp png_ptr, png_const_bytep chunk_string,
png_const_bytep data, png_size_t length) png_const_bytep data, png_size_t length)
{ {
png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data, png_write_complete_chunk(png_ptr, PNG_CHUNK_FROM_STRING(chunk_string), data,
length); length);
} }
/* This is used below to find the size of an image to pass to png_deflate_claim, /* This is used below to find the size of an image to pass to png_deflate_claim,
@ -291,7 +291,7 @@ optimize_cmf(png_bytep data, png_alloc_size_t data_size)
/* Initialize the compressor for the appropriate type of compression. */ /* Initialize the compressor for the appropriate type of compression. */
static int static int
png_deflate_claim(png_structrp png_ptr, png_uint_32 owner, png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
png_alloc_size_t data_size) png_alloc_size_t data_size)
{ {
if (png_ptr->zowner != 0) if (png_ptr->zowner != 0)
{ {
@ -416,7 +416,7 @@ png_deflate_claim(png_structrp png_ptr, png_uint_32 owner,
else else
{ {
ret = deflateInit2(&png_ptr->zstream, level, method, windowBits, ret = deflateInit2(&png_ptr->zstream, level, method, windowBits,
memLevel, strategy); memLevel, strategy);
if (ret == Z_OK) if (ret == Z_OK)
png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED; png_ptr->flags |= PNG_FLAG_ZSTREAM_INITIALIZED;
@ -477,7 +477,7 @@ typedef struct
static void static void
png_text_compress_init(compression_state *comp, png_const_bytep input, png_text_compress_init(compression_state *comp, png_const_bytep input,
png_alloc_size_t input_len) png_alloc_size_t input_len)
{ {
comp->input = input; comp->input = input;
comp->input_len = input_len; comp->input_len = input_len;
@ -487,7 +487,7 @@ png_text_compress_init(compression_state *comp, png_const_bytep input,
/* Compress the data in the compression state input */ /* Compress the data in the compression state input */
static int static int
png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name, png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
compression_state *comp, png_uint_32 prefix_len) compression_state *comp, png_uint_32 prefix_len)
{ {
int ret; int ret;
@ -579,7 +579,7 @@ png_text_compress(png_structrp png_ptr, png_uint_32 chunk_name,
/* Compress the data */ /* Compress the data */
ret = deflate(&png_ptr->zstream, ret = deflate(&png_ptr->zstream,
input_len > 0 ? Z_NO_FLUSH : Z_FINISH); input_len > 0 ? Z_NO_FLUSH : Z_FINISH);
/* Claw back input data that was not consumed (because avail_in is /* Claw back input data that was not consumed (because avail_in is
* reset above every time round the loop). * reset above every time round the loop).
@ -925,7 +925,7 @@ png_write_PLTE(png_structrp png_ptr, png_const_colorp palette,
*/ */
void /* PRIVATE */ void /* PRIVATE */
png_compress_IDAT(png_structrp png_ptr, png_const_bytep input, png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
png_alloc_size_t input_len, int flush) png_alloc_size_t input_len, int flush)
{ {
if (png_ptr->zowner != png_IDAT) if (png_ptr->zowner != png_IDAT)
{ {
@ -937,7 +937,7 @@ png_compress_IDAT(png_structrp png_ptr, png_const_bytep input,
if (png_ptr->zbuffer_list == NULL) if (png_ptr->zbuffer_list == NULL)
{ {
png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp, png_ptr->zbuffer_list = png_voidcast(png_compression_bufferp,
png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr))); png_malloc(png_ptr, PNG_COMPRESSION_BUFFER_SIZE(png_ptr)));
png_ptr->zbuffer_list->next = NULL; png_ptr->zbuffer_list->next = NULL;
} }
@ -1358,7 +1358,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
/* Write the chunk out as it is */ /* Write the chunk out as it is */
png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha, png_write_complete_chunk(png_ptr, png_tRNS, trans_alpha,
(png_size_t)num_trans); (png_size_t)num_trans);
} }
else if (color_type == PNG_COLOR_TYPE_GRAY) else if (color_type == PNG_COLOR_TYPE_GRAY)
@ -1389,7 +1389,7 @@ png_write_tRNS(png_structrp png_ptr, png_const_bytep trans_alpha,
#endif #endif
{ {
png_app_warning(png_ptr, png_app_warning(png_ptr,
"Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8"); "Ignoring attempt to write 16-bit tRNS chunk when bit_depth is 8");
return; return;
} }
@ -1441,7 +1441,8 @@ png_write_bKGD(png_structrp png_ptr, png_const_color_16p back, int color_type)
#endif #endif
{ {
png_warning(png_ptr, png_warning(png_ptr,
"Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8"); "Ignoring attempt to write 16-bit bKGD chunk "
"when bit_depth is 8");
return; return;
} }
@ -1571,7 +1572,7 @@ png_write_zTXt(png_structrp png_ptr, png_const_charp key, png_const_charp text,
/* Compute the compressed data; do it now for the length */ /* Compute the compressed data; do it now for the length */
png_text_compress_init(&comp, (png_const_bytep)text, png_text_compress_init(&comp, (png_const_bytep)text,
text == NULL ? 0 : strlen(text)); text == NULL ? 0 : strlen(text));
if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK) if (png_text_compress(png_ptr, png_zTXt, &comp, key_len) != Z_OK)
png_error(png_ptr, png_ptr->zstream.msg); png_error(png_ptr, png_ptr->zstream.msg);
@ -1941,7 +1942,7 @@ png_write_start_row(png_structrp png_ptr)
*/ */
if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0) if ((filters & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH)) != 0)
png_ptr->prev_row = png_voidcast(png_bytep, png_ptr->prev_row = png_voidcast(png_bytep,
png_calloc(png_ptr, buf_size)); png_calloc(png_ptr, buf_size));
#endif /* WRITE_FILTER */ #endif /* WRITE_FILTER */
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
@ -2244,7 +2245,7 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
*/ */
static void /* PRIVATE */ static void /* PRIVATE */
png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row, png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
png_size_t row_bytes); png_size_t row_bytes);
#ifdef PNG_WRITE_FILTER_SUPPORTED #ifdef PNG_WRITE_FILTER_SUPPORTED
static png_size_t /* PRIVATE */ static png_size_t /* PRIVATE */
@ -2262,14 +2263,22 @@ png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp,
i++, rp++, dp++) i++, rp++, dp++)
{ {
v = *dp = *rp; v = *dp = *rp;
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
} }
for (lp = png_ptr->row_buf + 1; i < row_bytes; for (lp = png_ptr->row_buf + 1; i < row_bytes;
i++, rp++, lp++, dp++) i++, rp++, lp++, dp++)
{ {
v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff); v = *dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
if (sum > lmins) /* We are already worse, don't continue. */ if (sum > lmins) /* We are already worse, don't continue. */
break; break;
@ -2278,6 +2287,28 @@ png_setup_sub_row(png_structrp png_ptr, const png_uint_32 bpp,
return (sum); return (sum);
} }
static void /* PRIVATE */
png_setup_sub_row_only(png_structrp png_ptr, const png_uint_32 bpp,
const png_size_t row_bytes)
{
png_bytep rp, dp, lp;
png_size_t i;
png_ptr->try_row[0] = PNG_FILTER_VALUE_SUB;
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1; i < bpp;
i++, rp++, dp++)
{
*dp = *rp;
}
for (lp = png_ptr->row_buf + 1; i < row_bytes;
i++, rp++, lp++, dp++)
{
*dp = (png_byte)(((int)*rp - (int)*lp) & 0xff);
}
}
static png_size_t /* PRIVATE */ static png_size_t /* PRIVATE */
png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes, png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
const png_size_t lmins) const png_size_t lmins)
@ -2294,7 +2325,11 @@ png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
i++, rp++, pp++, dp++) i++, rp++, pp++, dp++)
{ {
v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff); v = *dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
if (sum > lmins) /* We are already worse, don't continue. */ if (sum > lmins) /* We are already worse, don't continue. */
break; break;
@ -2302,10 +2337,25 @@ png_setup_up_row(png_structrp png_ptr, const png_size_t row_bytes,
return (sum); return (sum);
} }
static void /* PRIVATE */
png_setup_up_row_only(png_structrp png_ptr, const png_size_t row_bytes)
{
png_bytep rp, dp, pp;
png_size_t i;
png_ptr->try_row[0] = PNG_FILTER_VALUE_UP;
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
pp = png_ptr->prev_row + 1; i < row_bytes;
i++, rp++, pp++, dp++)
{
*dp = (png_byte)(((int)*rp - (int)*pp) & 0xff);
}
}
static png_size_t /* PRIVATE */ static png_size_t /* PRIVATE */
png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp, png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
const png_size_t row_bytes, const png_size_t lmins) const png_size_t row_bytes, const png_size_t lmins)
{ {
png_bytep rp, dp, pp, lp; png_bytep rp, dp, pp, lp;
png_uint_32 i; png_uint_32 i;
@ -2315,11 +2365,15 @@ png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG; png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG;
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1, for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
pp = png_ptr->prev_row + 1; i < bpp; i++) pp = png_ptr->prev_row + 1; i < bpp; i++)
{ {
v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff); v = *dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
} }
for (lp = png_ptr->row_buf + 1; i < row_bytes; i++) for (lp = png_ptr->row_buf + 1; i < row_bytes; i++)
@ -2327,7 +2381,11 @@ png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
v = *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2)) v = *dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
& 0xff); & 0xff);
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
if (sum > lmins) /* We are already worse, don't continue. */ if (sum > lmins) /* We are already worse, don't continue. */
break; break;
@ -2335,6 +2393,27 @@ png_setup_avg_row(png_structrp png_ptr, const png_uint_32 bpp,
return (sum); return (sum);
} }
static void /* PRIVATE */
png_setup_avg_row_only(png_structrp png_ptr, const png_uint_32 bpp,
const png_size_t row_bytes)
{
png_bytep rp, dp, pp, lp;
png_uint_32 i;
png_ptr->try_row[0] = PNG_FILTER_VALUE_AVG;
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
pp = png_ptr->prev_row + 1; i < bpp; i++)
{
*dp++ = (png_byte)(((int)*rp++ - ((int)*pp++ / 2)) & 0xff);
}
for (lp = png_ptr->row_buf + 1; i < row_bytes; i++)
{
*dp++ = (png_byte)(((int)*rp++ - (((int)*pp++ + (int)*lp++) / 2))
& 0xff);
}
}
static png_size_t /* PRIVATE */ static png_size_t /* PRIVATE */
png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp, png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
@ -2352,7 +2431,11 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
{ {
v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff); v = *dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
} }
for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes; for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes;
@ -2381,7 +2464,11 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff); v = *dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
if (sum > lmins) /* We are already worse, don't continue. */ if (sum > lmins) /* We are already worse, don't continue. */
break; break;
@ -2389,6 +2476,48 @@ png_setup_paeth_row(png_structrp png_ptr, const png_uint_32 bpp,
return (sum); return (sum);
} }
static void /* PRIVATE */
png_setup_paeth_row_only(png_structrp png_ptr, const png_uint_32 bpp,
const png_size_t row_bytes)
{
png_bytep rp, dp, pp, cp, lp;
png_size_t i;
png_ptr->try_row[0] = PNG_FILTER_VALUE_PAETH;
for (i = 0, rp = png_ptr->row_buf + 1, dp = png_ptr->try_row + 1,
pp = png_ptr->prev_row + 1; i < bpp; i++)
{
*dp++ = (png_byte)(((int)*rp++ - (int)*pp++) & 0xff);
}
for (lp = png_ptr->row_buf + 1, cp = png_ptr->prev_row + 1; i < row_bytes;
i++)
{
int a, b, c, pa, pb, pc, p;
b = *pp++;
c = *cp++;
a = *lp++;
p = b - c;
pc = a - c;
#ifdef PNG_USE_ABS
pa = abs(p);
pb = abs(pc);
pc = abs(p + pc);
#else
pa = p < 0 ? -p : p;
pb = pc < 0 ? -pc : pc;
pc = (p + pc) < 0 ? -(p + pc) : p + pc;
#endif
p = (pa <= pb && pa <=pc) ? a : (pb <= pc) ? b : c;
*dp++ = (png_byte)(((int)*rp++ - p) & 0xff);
}
}
#endif /* WRITE_FILTER */ #endif /* WRITE_FILTER */
void /* PRIVATE */ void /* PRIVATE */
@ -2397,7 +2526,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
#ifndef PNG_WRITE_FILTER_SUPPORTED #ifndef PNG_WRITE_FILTER_SUPPORTED
png_write_filtered_row(png_ptr, png_ptr->row_buf, row_info->rowbytes+1); png_write_filtered_row(png_ptr, png_ptr->row_buf, row_info->rowbytes+1);
#else #else
png_byte filter_to_do = png_ptr->do_filter; unsigned int filter_to_do = png_ptr->do_filter;
png_bytep row_buf; png_bytep row_buf;
png_bytep best_row; png_bytep best_row;
png_uint_32 bpp; png_uint_32 bpp;
@ -2443,32 +2572,33 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
*/ */
best_row = png_ptr->row_buf; best_row = png_ptr->row_buf;
if (PNG_SIZE_MAX/128 <= row_bytes)
if ((filter_to_do & PNG_FILTER_NONE) != 0 && filter_to_do != PNG_FILTER_NONE)
{ {
/* Overflow can occur in the calculation, just select the lowest set
* filter.
*/
filter_to_do &= 0U-filter_to_do;
}
else if ((filter_to_do & PNG_FILTER_NONE) != 0 &&
filter_to_do != PNG_FILTER_NONE)
{
/* Overflow not possible and multiple filters in the list, including the
* 'none' filter.
*/
png_bytep rp; png_bytep rp;
png_size_t sum = 0; png_size_t sum = 0;
png_size_t i; png_size_t i;
int v; int v;
if (PNG_SIZE_MAX/128 <= row_bytes)
{
for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
{
/* Check for overflow */
if (sum > PNG_SIZE_MAX/128 - 256)
break;
v = *rp;
sum += (v < 128) ? v : 256 - v;
}
}
else /* Overflow is not possible */
{ {
for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++) for (i = 0, rp = row_buf + 1; i < row_bytes; i++, rp++)
{ {
v = *rp; v = *rp;
#ifdef PNG_USE_ABS
sum += 128 - abs(v - 128);
#else
sum += (v < 128) ? v : 256 - v; sum += (v < 128) ? v : 256 - v;
#endif
} }
} }
@ -2479,7 +2609,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
if (filter_to_do == PNG_FILTER_SUB) if (filter_to_do == PNG_FILTER_SUB)
/* It's the only filter so no testing is needed */ /* It's the only filter so no testing is needed */
{ {
(void) png_setup_sub_row(png_ptr, bpp, row_bytes, mins); png_setup_sub_row_only(png_ptr, bpp, row_bytes);
best_row = png_ptr->try_row; best_row = png_ptr->try_row;
} }
@ -2505,7 +2635,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
/* Up filter */ /* Up filter */
if (filter_to_do == PNG_FILTER_UP) if (filter_to_do == PNG_FILTER_UP)
{ {
(void) png_setup_up_row(png_ptr, row_bytes, mins); png_setup_up_row_only(png_ptr, row_bytes);
best_row = png_ptr->try_row; best_row = png_ptr->try_row;
} }
@ -2531,7 +2661,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
/* Avg filter */ /* Avg filter */
if (filter_to_do == PNG_FILTER_AVG) if (filter_to_do == PNG_FILTER_AVG)
{ {
(void) png_setup_avg_row(png_ptr, bpp, row_bytes, mins); png_setup_avg_row_only(png_ptr, bpp, row_bytes);
best_row = png_ptr->try_row; best_row = png_ptr->try_row;
} }
@ -2555,9 +2685,9 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
} }
/* Paeth filter */ /* Paeth filter */
if ((filter_to_do == PNG_FILTER_PAETH) != 0) if (filter_to_do == PNG_FILTER_PAETH)
{ {
(void) png_setup_paeth_row(png_ptr, bpp, row_bytes, mins); png_setup_paeth_row_only(png_ptr, bpp, row_bytes);
best_row = png_ptr->try_row; best_row = png_ptr->try_row;
} }
@ -2589,7 +2719,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
/* Do the actual writing of a previously filtered row. */ /* Do the actual writing of a previously filtered row. */
static void static void
png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row, png_write_filtered_row(png_structrp png_ptr, png_bytep filtered_row,
png_size_t full_row_length/*includes filter byte*/) png_size_t full_row_length/*includes filter byte*/)
{ {
png_debug(1, "in png_write_filtered_row"); png_debug(1, "in png_write_filtered_row");