mewin/libpng
1
0
Fork 0
mirror of https://git.code.sf.net/p/libpng/code.git synced 2025-07-10 18:04:09 +02:00
Code Issues Projects Releases Wiki Activity

[libpng16] Fix some indentation.

Browse Source
This commit is contained in:
Glenn Randers-Pehrson 2015-06-11 22:00:14 -05:00
parent c6f629ffdd
commit f86720c6c0
5 changed files with 327 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
png.c
View File

@ -243,15 +243,15 @@ png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
create_struct.user_height_max = PNG_USER_HEIGHT_MAX; create_struct.user_height_max = PNG_USER_HEIGHT_MAX;
# ifdef PNG_USER_CHUNK_CACHE_MAX # ifdef PNG_USER_CHUNK_CACHE_MAX
/* Added at libpng-1.2.43 and 1.4.0 */ /* Added at libpng-1.2.43 and 1.4.0 */
create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX; create_struct.user_chunk_cache_max = PNG_USER_CHUNK_CACHE_MAX;
# endif # endif
# ifdef PNG_USER_CHUNK_MALLOC_MAX # ifdef PNG_USER_CHUNK_MALLOC_MAX
/* Added at libpng-1.2.43 and 1.4.1, required only for read but exists /* Added at libpng-1.2.43 and 1.4.1, required only for read but exists
* in png_struct regardless. * in png_struct regardless.
*/ */
create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX; create_struct.user_chunk_malloc_max = PNG_USER_CHUNK_MALLOC_MAX;
# endif # endif
# endif # endif
@ -304,10 +304,10 @@ png_create_png_struct,(png_const_charp user_png_ver, png_voidp error_ptr,
create_struct.zstream.opaque = png_ptr; create_struct.zstream.opaque = png_ptr;
# ifdef PNG_SETJMP_SUPPORTED # ifdef PNG_SETJMP_SUPPORTED
/* Eliminate the local error handling: */ /* Eliminate the local error handling: */
create_struct.jmp_buf_ptr = NULL; create_struct.jmp_buf_ptr = NULL;
create_struct.jmp_buf_size = 0; create_struct.jmp_buf_size = 0;
create_struct.longjmp_fn = 0; create_struct.longjmp_fn = 0;
# endif # endif
*png_ptr = create_struct; *png_ptr = create_struct;
@ -766,13 +766,13 @@ 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.18beta08 - June 6, 2015" PNG_STRING_NEWLINE \ "libpng version 1.6.18beta08 - June 11, 2015" PNG_STRING_NEWLINE \
"Copyright (c) 1998-2015 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \ "Copyright (c) 1998-2015 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
"Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \ "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
"Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \ "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
PNG_STRING_NEWLINE; PNG_STRING_NEWLINE;
# else # else
return "libpng version 1.6.18beta08 - June 6, 2015\ return "libpng version 1.6.18beta08 - June 11, 2015\
Copyright (c) 1998-2015 Glenn Randers-Pehrson\ Copyright (c) 1998-2015 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.";
@ -811,9 +811,9 @@ png_get_header_version(png_const_structrp png_ptr)
#ifdef __STDC__ #ifdef __STDC__
return PNG_HEADER_VERSION_STRING return PNG_HEADER_VERSION_STRING
# ifndef PNG_READ_SUPPORTED # ifndef PNG_READ_SUPPORTED
" (NO READ SUPPORT)" " (NO READ SUPPORT)"
# endif # endif
PNG_STRING_NEWLINE; PNG_STRING_NEWLINE;
#else #else
return PNG_HEADER_VERSION_STRING; return PNG_HEADER_VERSION_STRING;
#endif #endif
@ -1086,10 +1086,10 @@ png_colorspace_set_gamma(png_const_structrp png_ptr,
errmsg = "gamma value out of range"; errmsg = "gamma value out of range";
# ifdef PNG_READ_gAMA_SUPPORTED # ifdef PNG_READ_gAMA_SUPPORTED
/* Allow the application to set the gamma value more than once */ /* Allow the application to set the gamma value more than once */
else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 && else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
(colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0) (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)
errmsg = "duplicate"; errmsg = "duplicate";
# endif # endif
/* Do nothing if the colorspace is already invalid */ /* Do nothing if the colorspace is already invalid */
@ -1130,31 +1130,31 @@ png_colorspace_sync_info(png_const_structrp png_ptr, png_inforp info_ptr)
PNG_INFO_iCCP); PNG_INFO_iCCP);
# ifdef PNG_COLORSPACE_SUPPORTED # ifdef PNG_COLORSPACE_SUPPORTED
/* Clean up the iCCP profile now if it won't be used. */ /* Clean up the iCCP profile now if it won't be used. */
png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/); png_free_data(png_ptr, info_ptr, PNG_FREE_ICCP, -1/*not used*/);
# else # else
PNG_UNUSED(png_ptr) PNG_UNUSED(png_ptr)
# endif # endif
} }
else else
{ {
# ifdef PNG_COLORSPACE_SUPPORTED # ifdef PNG_COLORSPACE_SUPPORTED
/* Leave the INFO_iCCP flag set if the pngset.c code has already set /* Leave the INFO_iCCP flag set if the pngset.c code has already set
* it; this allows a PNG to contain a profile which matches sRGB and * it; this allows a PNG to contain a profile which matches sRGB and
* yet still have that profile retrievable by the application. * yet still have that profile retrievable by the application.
*/ */
if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0) if ((info_ptr->colorspace.flags & PNG_COLORSPACE_MATCHES_sRGB) != 0)
info_ptr->valid |= PNG_INFO_sRGB; info_ptr->valid |= PNG_INFO_sRGB;
else else
info_ptr->valid &= ~PNG_INFO_sRGB; info_ptr->valid &= ~PNG_INFO_sRGB;
if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0) if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_ENDPOINTS) != 0)
info_ptr->valid |= PNG_INFO_cHRM; info_ptr->valid |= PNG_INFO_cHRM;
else else
info_ptr->valid &= ~PNG_INFO_cHRM; info_ptr->valid &= ~PNG_INFO_cHRM;
# endif # endif
if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0) if ((info_ptr->colorspace.flags & PNG_COLORSPACE_HAVE_GAMMA) != 0)

13
pngpread.c
View File

@ -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;
@ -134,7 +134,7 @@ void /* PRIVATE */
png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr) png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
{ {
png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */ png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */
num_to_check = 8 - num_checked; num_to_check = 8 - num_checked;
if (png_ptr->buffer_size < num_to_check) if (png_ptr->buffer_size < num_to_check)
{ {
@ -606,6 +606,7 @@ png_push_read_IDAT(png_structrp png_ptr)
png_ptr->current_buffer_size -= save_size; png_ptr->current_buffer_size -= save_size;
png_ptr->current_buffer_ptr += save_size; png_ptr->current_buffer_ptr += save_size;
} }
if (png_ptr->idat_size == 0) if (png_ptr->idat_size == 0)
{ {
PNG_PUSH_SAVE_BUFFER_IF_LT(4) PNG_PUSH_SAVE_BUFFER_IF_LT(4)

2
pngread.c
View File

@ -1209,7 +1209,7 @@ png_read_png(png_structrp png_ptr, png_inforp info_ptr,
for (iptr = 0; iptr < info_ptr->height; iptr++) for (iptr = 0; iptr < info_ptr->height; iptr++)
info_ptr->row_pointers[iptr] = png_voidcast(png_bytep, info_ptr->row_pointers[iptr] = png_voidcast(png_bytep,
png_malloc(png_ptr, info_ptr->rowbytes)); png_malloc(png_ptr, info_ptr->rowbytes));
} }
png_read_image(png_ptr, info_ptr->row_pointers); png_read_image(png_ptr, info_ptr->row_pointers);

342
pngrutil.c
View File

@ -1146,11 +1146,13 @@ png_handle_sBIT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
return; return;
for (i=0; i<truelen; ++i) for (i=0; i<truelen; ++i)
{
if (buf[i] == 0 || buf[i] > sample_depth) if (buf[i] == 0 || buf[i] > sample_depth)
{ {
png_chunk_benign_error(png_ptr, "invalid"); png_chunk_benign_error(png_ptr, "invalid");
return; return;
} }
}
if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0) if ((png_ptr->color_type & PNG_COLOR_MASK_COLOR) != 0)
{ {
@ -1461,10 +1463,10 @@ png_handle_iCCP(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
finished = 1; finished = 1;
# ifdef PNG_sRGB_SUPPORTED # ifdef PNG_sRGB_SUPPORTED
/* 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. */
@ -1674,8 +1676,8 @@ png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
if (dl > max_dl) if (dl > max_dl)
{ {
png_warning(png_ptr, "sPLT chunk too long"); png_warning(png_ptr, "sPLT chunk too long");
return; return;
} }
new_palette.nentries = (png_int_32)(data_length / entry_size); new_palette.nentries = (png_int_32)(data_length / entry_size);
@ -1685,8 +1687,8 @@ png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
if (new_palette.entries == NULL) if (new_palette.entries == NULL)
{ {
png_warning(png_ptr, "sPLT chunk requires too much memory"); png_warning(png_ptr, "sPLT chunk requires too much memory");
return; return;
} }
#ifdef PNG_POINTER_INDEXING_SUPPORTED #ifdef PNG_POINTER_INDEXING_SUPPORTED
@ -2716,13 +2718,13 @@ png_cache_unknown_chunk(png_structrp png_ptr, png_uint_32 length)
} }
# ifdef PNG_SET_USER_LIMITS_SUPPORTED # ifdef PNG_SET_USER_LIMITS_SUPPORTED
if (png_ptr->user_chunk_malloc_max > 0 && if (png_ptr->user_chunk_malloc_max > 0 &&
png_ptr->user_chunk_malloc_max < limit) png_ptr->user_chunk_malloc_max < limit)
limit = png_ptr->user_chunk_malloc_max; limit = png_ptr->user_chunk_malloc_max;
# elif PNG_USER_CHUNK_MALLOC_MAX > 0 # elif PNG_USER_CHUNK_MALLOC_MAX > 0
if (PNG_USER_CHUNK_MALLOC_MAX < limit) if (PNG_USER_CHUNK_MALLOC_MAX < limit)
limit = PNG_USER_CHUNK_MALLOC_MAX; limit = PNG_USER_CHUNK_MALLOC_MAX;
# endif # endif
if (length <= limit) if (length <= limit)
@ -2785,7 +2787,7 @@ png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
*/ */
# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED # ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
# ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED # ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
keep = png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name); keep = png_chunk_unknown_handling(png_ptr, png_ptr->chunk_name);
# endif # endif
# endif # endif
@ -2794,153 +2796,153 @@ png_handle_unknown(png_structrp png_ptr, png_inforp info_ptr,
* PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) * PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
*/ */
# ifdef PNG_READ_USER_CHUNKS_SUPPORTED # ifdef PNG_READ_USER_CHUNKS_SUPPORTED
/* The user callback takes precedence over the chunk keep value, but the /* The user callback takes precedence over the chunk keep value, but the
* keep value is still required to validate a save of a critical chunk. * keep value is still required to validate a save of a critical chunk.
*/ */
if (png_ptr->read_user_chunk_fn != NULL) if (png_ptr->read_user_chunk_fn != NULL)
{
if (png_cache_unknown_chunk(png_ptr, length) != 0)
{ {
if (png_cache_unknown_chunk(png_ptr, length) != 0) /* Callback to user unknown chunk handler */
int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr,
&png_ptr->unknown_chunk);
/* ret is:
* negative: An error occurred; png_chunk_error will be called.
* zero: The chunk was not handled, the chunk will be discarded
* unless png_set_keep_unknown_chunks has been used to set
* a 'keep' behavior for this particular chunk, in which
* case that will be used. A critical chunk will cause an
* error at this point unless it is to be saved.
* positive: The chunk was handled, libpng will ignore/discard it.
*/
if (ret < 0)
png_chunk_error(png_ptr, "error in user chunk");
else if (ret == 0)
{ {
/* Callback to user unknown chunk handler */ /* If the keep value is 'default' or 'never' override it, but
int ret = (*(png_ptr->read_user_chunk_fn))(png_ptr, * still error out on critical chunks unless the keep value is
&png_ptr->unknown_chunk); * 'always' While this is weird it is the behavior in 1.4.12.
* A possible improvement would be to obey the value set for the
/* ret is: * chunk, but this would be an API change that would probably
* negative: An error occurred; png_chunk_error will be called. * damage some applications.
* zero: The chunk was not handled, the chunk will be discarded *
* unless png_set_keep_unknown_chunks has been used to set * The png_app_warning below catches the case that matters, where
* a 'keep' behavior for this particular chunk, in which * the application has not set specific save or ignore for this
* case that will be used. A critical chunk will cause an * chunk or global save or ignore.
* error at this point unless it is to be saved.
* positive: The chunk was handled, libpng will ignore/discard it.
*/ */
if (ret < 0) if (keep < PNG_HANDLE_CHUNK_IF_SAFE)
png_chunk_error(png_ptr, "error in user chunk");
else if (ret == 0)
{ {
/* If the keep value is 'default' or 'never' override it, but # ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
* still error out on critical chunks unless the keep value is if (png_ptr->unknown_default < PNG_HANDLE_CHUNK_IF_SAFE)
* 'always' While this is weird it is the behavior in 1.4.12.
* A possible improvement would be to obey the value set for the
* chunk, but this would be an API change that would probably
* damage some applications.
*
* The png_app_warning below catches the case that matters, where
* the application has not set specific save or ignore for this
* chunk or global save or ignore.
*/
if (keep < PNG_HANDLE_CHUNK_IF_SAFE)
{ {
# ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED png_chunk_warning(png_ptr, "Saving unknown chunk:");
if (png_ptr->unknown_default < PNG_HANDLE_CHUNK_IF_SAFE) png_app_warning(png_ptr,
{ "forcing save of an unhandled chunk;"
png_chunk_warning(png_ptr, "Saving unknown chunk:"); " please call png_set_keep_unknown_chunks");
png_app_warning(png_ptr, /* with keep = PNG_HANDLE_CHUNK_IF_SAFE */
"forcing save of an unhandled chunk;"
" please call png_set_keep_unknown_chunks");
/* with keep = PNG_HANDLE_CHUNK_IF_SAFE */
}
# endif
keep = PNG_HANDLE_CHUNK_IF_SAFE;
} }
} # endif
keep = PNG_HANDLE_CHUNK_IF_SAFE;
else /* chunk was handled */
{
handled = 1;
/* Critical chunks can be safely discarded at this point. */
keep = PNG_HANDLE_CHUNK_NEVER;
} }
} }
else else /* chunk was handled */
keep = PNG_HANDLE_CHUNK_NEVER; /* insufficient memory */ {
handled = 1;
/* Critical chunks can be safely discarded at this point. */
keep = PNG_HANDLE_CHUNK_NEVER;
}
} }
else else
/* Use the SAVE_UNKNOWN_CHUNKS code or skip the chunk */ keep = PNG_HANDLE_CHUNK_NEVER; /* insufficient memory */
}
else
/* Use the SAVE_UNKNOWN_CHUNKS code or skip the chunk */
# endif /* READ_USER_CHUNKS */ # endif /* READ_USER_CHUNKS */
# ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED # ifdef PNG_SAVE_UNKNOWN_CHUNKS_SUPPORTED
{
/* keep is currently just the per-chunk setting, if there was no
* setting change it to the global default now (not that this may
* still be AS_DEFAULT) then obtain the cache of the chunk if required,
* if not simply skip the chunk.
*/
if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
keep = png_ptr->unknown_default;
if (keep == PNG_HANDLE_CHUNK_ALWAYS ||
(keep == PNG_HANDLE_CHUNK_IF_SAFE &&
PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
{ {
/* keep is currently just the per-chunk setting, if there was no if (png_cache_unknown_chunk(png_ptr, length) == 0)
* setting change it to the global default now (not that this may keep = PNG_HANDLE_CHUNK_NEVER;
* still be AS_DEFAULT) then obtain the cache of the chunk if required,
* if not simply skip the chunk.
*/
if (keep == PNG_HANDLE_CHUNK_AS_DEFAULT)
keep = png_ptr->unknown_default;
if (keep == PNG_HANDLE_CHUNK_ALWAYS ||
(keep == PNG_HANDLE_CHUNK_IF_SAFE &&
PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
{
if (png_cache_unknown_chunk(png_ptr, length) == 0)
keep = PNG_HANDLE_CHUNK_NEVER;
}
else
png_crc_finish(png_ptr, length);
} }
else
png_crc_finish(png_ptr, length);
}
# else # else
# ifndef PNG_READ_USER_CHUNKS_SUPPORTED # ifndef PNG_READ_USER_CHUNKS_SUPPORTED
# error no method to support READ_UNKNOWN_CHUNKS # error no method to support READ_UNKNOWN_CHUNKS
# endif # endif
{ {
/* If here there is no read callback pointer set and no support is /* If here there is no read callback pointer set and no support is
* compiled in to just save the unknown chunks, so simply skip this * compiled in to just save the unknown chunks, so simply skip this
* chunk. If 'keep' is something other than AS_DEFAULT or NEVER then * chunk. If 'keep' is something other than AS_DEFAULT or NEVER then
* the app has erroneously asked for unknown chunk saving when there * the app has erroneously asked for unknown chunk saving when there
* is no support. * is no support.
*/ */
if (keep > PNG_HANDLE_CHUNK_NEVER) if (keep > PNG_HANDLE_CHUNK_NEVER)
png_app_error(png_ptr, "no unknown chunk support available"); png_app_error(png_ptr, "no unknown chunk support available");
png_crc_finish(png_ptr, length); png_crc_finish(png_ptr, length);
} }
# endif # endif
# ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED # ifdef PNG_STORE_UNKNOWN_CHUNKS_SUPPORTED
/* Now store the chunk in the chunk list if appropriate, and if the limits /* Now store the chunk in the chunk list if appropriate, and if the limits
* permit it. * permit it.
*/ */
if (keep == PNG_HANDLE_CHUNK_ALWAYS || if (keep == PNG_HANDLE_CHUNK_ALWAYS ||
(keep == PNG_HANDLE_CHUNK_IF_SAFE && (keep == PNG_HANDLE_CHUNK_IF_SAFE &&
PNG_CHUNK_ANCILLARY(png_ptr->chunk_name))) PNG_CHUNK_ANCILLARY(png_ptr->chunk_name)))
{
# ifdef PNG_USER_LIMITS_SUPPORTED
switch (png_ptr->user_chunk_cache_max)
{ {
# ifdef PNG_USER_LIMITS_SUPPORTED case 2:
switch (png_ptr->user_chunk_cache_max) png_ptr->user_chunk_cache_max = 1;
{ png_chunk_benign_error(png_ptr, "no space in chunk cache");
case 2: /* FALL THROUGH */
png_ptr->user_chunk_cache_max = 1; case 1:
png_chunk_benign_error(png_ptr, "no space in chunk cache"); /* NOTE: prior to 1.6.0 this case resulted in an unknown critical
/* FALL THROUGH */ * chunk being skipped, now there will be a hard error below.
case 1: */
/* NOTE: prior to 1.6.0 this case resulted in an unknown critical break;
* chunk being skipped, now there will be a hard error below.
*/
break;
default: /* not at limit */ default: /* not at limit */
--(png_ptr->user_chunk_cache_max); --(png_ptr->user_chunk_cache_max);
/* FALL THROUGH */ /* FALL THROUGH */
case 0: /* no limit */ case 0: /* no limit */
# endif /* USER_LIMITS */ # endif /* USER_LIMITS */
/* Here when the limit isn't reached or when limits are compiled /* Here when the limit isn't reached or when limits are compiled
* 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;
}
# endif
} }
# endif
}
# else /* no store support: the chunk must be handled by the user callback */ # else /* no store support: the chunk must be handled by the user callback */
PNG_UNUSED(info_ptr) PNG_UNUSED(info_ptr)
# endif # endif
/* Regardless of the error handling below the cached data (if any) can be /* Regardless of the error handling below the cached data (if any) can be
@ -3042,13 +3044,13 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
end_ptr = dp + PNG_ROWBYTES(pixel_depth, row_width) - 1; end_ptr = dp + PNG_ROWBYTES(pixel_depth, row_width) - 1;
end_byte = *end_ptr; end_byte = *end_ptr;
# ifdef PNG_READ_PACKSWAP_SUPPORTED # ifdef PNG_READ_PACKSWAP_SUPPORTED
if ((png_ptr->transformations & PNG_PACKSWAP) != 0) if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
/* little-endian byte */ /* little-endian byte */
end_mask = 0xff << end_mask; end_mask = 0xff << end_mask;
else /* big-endian byte */ else /* big-endian byte */
# endif # endif
end_mask = 0xff >> end_mask; end_mask = 0xff >> end_mask;
/* end_mask is now the bits to *keep* from the destination row */ /* end_mask is now the bits to *keep* from the destination row */
} }
@ -3206,12 +3208,12 @@ png_combine_row(png_const_structrp png_ptr, png_bytep dp, int display)
png_uint_32 mask; png_uint_32 mask;
# ifdef PNG_READ_PACKSWAP_SUPPORTED # ifdef PNG_READ_PACKSWAP_SUPPORTED
if ((png_ptr->transformations & PNG_PACKSWAP) != 0) if ((png_ptr->transformations & PNG_PACKSWAP) != 0)
mask = MASK(pass, pixel_depth, display, 0); mask = MASK(pass, pixel_depth, display, 0);
else else
# endif # endif
mask = MASK(pass, pixel_depth, display, 1); mask = MASK(pass, pixel_depth, display, 1);
for (;;) for (;;)
{ {
@ -3812,15 +3814,15 @@ png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info, png_bytep row,
p = b - c; p = b - c;
pc = a - c; pc = a - c;
# ifdef PNG_USE_ABS #ifdef PNG_USE_ABS
pa = abs(p); pa = abs(p);
pb = abs(pc); pb = abs(pc);
pc = abs(p + pc); pc = abs(p + pc);
# else #else
pa = p < 0 ? -p : p; pa = p < 0 ? -p : p;
pb = pc < 0 ? -pc : pc; pb = pc < 0 ? -pc : pc;
pc = (p + pc) < 0 ? -(p + pc) : p + pc; pc = (p + pc) < 0 ? -(p + pc) : p + pc;
# endif #endif
/* Find the best predictor, the least of pa, pb, pc favoring the earlier /* Find the best predictor, the least of pa, pb, pc favoring the earlier
* ones in the case of a tie. * ones in the case of a tie.
@ -3867,15 +3869,15 @@ png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info, png_bytep row,
p = b - c; p = b - c;
pc = a - c; pc = a - c;
# ifdef PNG_USE_ABS #ifdef PNG_USE_ABS
pa = abs(p); pa = abs(p);
pb = abs(pc); pb = abs(pc);
pc = abs(p + pc); pc = abs(p + pc);
# else #else
pa = p < 0 ? -p : p; pa = p < 0 ? -p : p;
pb = pc < 0 ? -pc : pc; pb = pc < 0 ? -pc : pc;
pc = (p + pc) < 0 ? -(p + pc) : p + pc; pc = (p + pc) < 0 ? -(p + pc) : p + pc;
# endif #endif
if (pb < pa) pa = pb, a = b; if (pb < pa) pa = pb, a = b;
if (pc < pa) a = c; if (pc < pa) a = c;
@ -4280,18 +4282,18 @@ png_read_start_row(png_structrp png_ptr)
#ifdef PNG_READ_EXPAND_16_SUPPORTED #ifdef PNG_READ_EXPAND_16_SUPPORTED
if ((png_ptr->transformations & PNG_EXPAND_16) != 0) if ((png_ptr->transformations & PNG_EXPAND_16) != 0)
{ {
# ifdef PNG_READ_EXPAND_SUPPORTED # ifdef PNG_READ_EXPAND_SUPPORTED
/* In fact it is an error if it isn't supported, but checking is /* In fact it is an error if it isn't supported, but checking is
* the safe way. * the safe way.
*/ */
if ((png_ptr->transformations & PNG_EXPAND) != 0) if ((png_ptr->transformations & PNG_EXPAND) != 0)
{ {
if (png_ptr->bit_depth < 16) if (png_ptr->bit_depth < 16)
max_pixel_depth *= 2; max_pixel_depth *= 2;
} }
else else
# endif # endif
png_ptr->transformations &= ~PNG_EXPAND_16; png_ptr->transformations &= ~PNG_EXPAND_16;
} }
#endif #endif

218
pngwrite.c
View File

@ -90,43 +90,44 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0) if ((png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE) == 0)
{ {
/* Write PNG signature */ /* Write PNG signature */
png_write_sig(png_ptr); png_write_sig(png_ptr);
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \ if ((png_ptr->mode & PNG_HAVE_PNG_SIGNATURE) != 0 && \
png_ptr->mng_features_permitted != 0) png_ptr->mng_features_permitted != 0)
{ {
png_warning(png_ptr, "MNG features are not allowed in a PNG datastream"); png_warning(png_ptr,
png_ptr->mng_features_permitted = 0; "MNG features are not allowed in a PNG datastream");
} png_ptr->mng_features_permitted = 0;
}
#endif #endif
/* Write IHDR information. */ /* Write IHDR information. */
png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height, png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type, info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
info_ptr->filter_type, info_ptr->filter_type,
#ifdef PNG_WRITE_INTERLACING_SUPPORTED #ifdef PNG_WRITE_INTERLACING_SUPPORTED
info_ptr->interlace_type info_ptr->interlace_type
#else #else
0 0
#endif #endif
); );
/* The rest of these check to see if the valid field has the appropriate /* The rest of these check to see if the valid field has the appropriate
* flag set, and if it does, writes the chunk. * flag set, and if it does, writes the chunk.
* *
* 1.6.0: COLORSPACE support controls the writing of these chunks too, and * 1.6.0: COLORSPACE support controls the writing of these chunks too, and
* the chunks will be written if the WRITE routine is there and information * the chunks will be written if the WRITE routine is there and
* is available in the COLORSPACE. (See png_colorspace_sync_info in png.c * information * is available in the COLORSPACE. (See
* for where the valid flags get set.) * png_colorspace_sync_info in png.c for where the valid flags get set.)
* *
* Under certain circumstances the colorspace can be invalidated without * Under certain circumstances the colorspace can be invalidated without
* syncing the info_struct 'valid' flags; this happens if libpng detects and * syncing the info_struct 'valid' flags; this happens if libpng detects
* error and calls png_error while the color space is being set, yet the * an error and calls png_error while the color space is being set, yet
* application continues writing the PNG. So check the 'invalid' flag here * the * application continues writing the PNG. So check the 'invalid'
* too. * flag here too.
*/ */
#ifdef PNG_GAMMA_SUPPORTED #ifdef PNG_GAMMA_SUPPORTED
# ifdef PNG_WRITE_gAMA_SUPPORTED # ifdef PNG_WRITE_gAMA_SUPPORTED
if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
@ -137,50 +138,50 @@ png_write_info_before_PLTE(png_structrp png_ptr, png_const_inforp info_ptr)
#endif #endif
#ifdef PNG_COLORSPACE_SUPPORTED #ifdef PNG_COLORSPACE_SUPPORTED
/* Write only one of sRGB or an ICC profile. If a profile was supplied /* Write only one of sRGB or an ICC profile. If a profile was supplied
* and it matches one of the known sRGB ones issue a warning. * and it matches one of the known sRGB ones issue a warning.
*/ */
# ifdef PNG_WRITE_iCCP_SUPPORTED # ifdef PNG_WRITE_iCCP_SUPPORTED
if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
(info_ptr->valid & PNG_INFO_iCCP) != 0) (info_ptr->valid & PNG_INFO_iCCP) != 0)
{ {
# 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
# endif # endif
# endif # endif
# ifdef PNG_WRITE_sRGB_SUPPORTED # ifdef PNG_WRITE_sRGB_SUPPORTED
if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
(info_ptr->valid & PNG_INFO_sRGB) != 0) (info_ptr->valid & PNG_INFO_sRGB) != 0)
png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent); png_write_sRGB(png_ptr, info_ptr->colorspace.rendering_intent);
# endif /* WRITE_sRGB */ # endif /* WRITE_sRGB */
#endif /* COLORSPACE */ #endif /* COLORSPACE */
#ifdef PNG_WRITE_sBIT_SUPPORTED #ifdef PNG_WRITE_sBIT_SUPPORTED
if ((info_ptr->valid & PNG_INFO_sBIT) != 0) if ((info_ptr->valid & PNG_INFO_sBIT) != 0)
png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type); png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
#endif #endif
#ifdef PNG_COLORSPACE_SUPPORTED #ifdef PNG_COLORSPACE_SUPPORTED
# ifdef PNG_WRITE_cHRM_SUPPORTED # ifdef PNG_WRITE_cHRM_SUPPORTED
if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 && if ((info_ptr->colorspace.flags & PNG_COLORSPACE_INVALID) == 0 &&
(info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 && (info_ptr->colorspace.flags & PNG_COLORSPACE_FROM_cHRM) != 0 &&
(info_ptr->valid & PNG_INFO_cHRM) != 0) (info_ptr->valid & PNG_INFO_cHRM) != 0)
png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy); png_write_cHRM_fixed(png_ptr, &info_ptr->colorspace.end_points_xy);
# endif # endif
#endif #endif
#ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED
write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR); write_unknown_chunks(png_ptr, info_ptr, PNG_HAVE_IHDR);
#endif #endif
png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE; png_ptr->mode |= PNG_WROTE_INFO_BEFORE_PLTE;
@ -854,7 +855,7 @@ png_write_row(png_structrp png_ptr, png_const_bytep row)
* which is also the output depth. * which is also the output depth.
*/ */
if (row_info.pixel_depth != png_ptr->pixel_depth || if (row_info.pixel_depth != png_ptr->pixel_depth ||
row_info.pixel_depth != png_ptr->transformed_pixel_depth) row_info.pixel_depth != png_ptr->transformed_pixel_depth)
png_error(png_ptr, "internal write transform logic error"); png_error(png_ptr, "internal write transform logic error");
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
@ -1385,14 +1386,14 @@ png_write_png(png_structrp png_ptr, png_inforp info_ptr,
* alpha channel. * alpha channel.
*/ */
if ((transforms & (PNG_TRANSFORM_STRIP_FILLER_AFTER| if ((transforms & (PNG_TRANSFORM_STRIP_FILLER_AFTER|
PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0) PNG_TRANSFORM_STRIP_FILLER_BEFORE)) != 0)
{ {
#ifdef PNG_WRITE_FILLER_SUPPORTED #ifdef PNG_WRITE_FILLER_SUPPORTED
if ((transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) != 0) if ((transforms & PNG_TRANSFORM_STRIP_FILLER_AFTER) != 0)
{ {
if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0) if ((transforms & PNG_TRANSFORM_STRIP_FILLER_BEFORE) != 0)
png_app_error(png_ptr, png_app_error(png_ptr,
"PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported"); "PNG_TRANSFORM_STRIP_FILLER: BEFORE+AFTER not supported");
/* Continue if ignored - this is the pre-1.6.10 behavior */ /* Continue if ignored - this is the pre-1.6.10 behavior */
png_set_filler(png_ptr, 0, PNG_FILLER_AFTER); png_set_filler(png_ptr, 0, PNG_FILLER_AFTER);
@ -1451,13 +1452,13 @@ 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_* */ # 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)
{ {
png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image, png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, image,
png_safe_error, png_safe_warning); png_safe_error, png_safe_warning);
if (png_ptr != NULL) if (png_ptr != NULL)
{ {
@ -1466,7 +1467,7 @@ png_image_write_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)
{ {
@ -1513,12 +1514,12 @@ static int
png_write_image_16bit(png_voidp argument) png_write_image_16bit(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_const_uint_16p input_row = png_voidcast(png_const_uint_16p, png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
display->first_row); display->first_row);
png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row); png_uint_16p output_row = png_voidcast(png_uint_16p, display->local_row);
png_uint_16p row_end; png_uint_16p row_end;
const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1; const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
@ -1527,17 +1528,18 @@ png_write_image_16bit(png_voidp argument)
if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0) if ((image->format & PNG_FORMAT_FLAG_ALPHA) != 0)
{ {
# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0) if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
aindex = -1; aindex = -1;
++input_row; /* To point to the first component */ ++input_row; /* To point to the first component */
++output_row; ++output_row;
} }
else else
# endif aindex = channels;
# else
aindex = channels; aindex = channels;
# endif
} }
else else
@ -1619,7 +1621,7 @@ png_write_image_16bit(png_voidp argument)
* calculation can be done to 15 bits of accuracy; however, the output needs to * calculation can be done to 15 bits of accuracy; however, the output needs to
* be scaled in the range 0..255*65535, so include that scaling here. * be scaled in the range 0..255*65535, so include that scaling here.
*/ */
#define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha) # define UNP_RECIPROCAL(alpha) ((((0xffff*0xff)<<7)+(alpha>>1))/alpha)
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,
@ -1670,12 +1672,12 @@ static int
png_write_image_8bit(png_voidp argument) png_write_image_8bit(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_const_uint_16p input_row = png_voidcast(png_const_uint_16p, png_const_uint_16p input_row = png_voidcast(png_const_uint_16p,
display->first_row); display->first_row);
png_bytep output_row = png_voidcast(png_bytep, display->local_row); png_bytep output_row = png_voidcast(png_bytep, display->local_row);
png_uint_32 y = image->height; png_uint_32 y = image->height;
const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1; const int channels = (image->format & PNG_FORMAT_FLAG_COLOR) != 0 ? 3 : 1;
@ -1685,17 +1687,17 @@ png_write_image_8bit(png_voidp argument)
png_bytep row_end; png_bytep row_end;
int aindex; int aindex;
# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0) if ((image->format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
aindex = -1; aindex = -1;
++input_row; /* To point to the first component */ ++input_row; /* To point to the first component */
++output_row; ++output_row;
} }
else else
# endif # endif
aindex = channels; aindex = channels;
/* Use row_end in place of a loop counter: */ /* Use row_end in place of a loop counter: */
row_end = output_row + image->width * (channels+1); row_end = output_row + image->width * (channels+1);
@ -1729,7 +1731,7 @@ png_write_image_8bit(png_voidp argument)
} /* while out_ptr < row_end */ } /* while out_ptr < row_end */
png_write_row(png_ptr, png_voidcast(png_const_bytep, png_write_row(png_ptr, png_voidcast(png_const_bytep,
display->local_row)); display->local_row));
input_row += display->row_bytes/(sizeof (png_uint_16)); input_row += display->row_bytes/(sizeof (png_uint_16));
} /* while y */ } /* while y */
} }
@ -1768,25 +1770,25 @@ png_image_set_PLTE(png_image_write_control *display)
const png_imagep image = display->image; const png_imagep image = display->image;
const void *cmap = display->colormap; const void *cmap = display->colormap;
const int entries = image->colormap_entries > 256 ? 256 : const int entries = image->colormap_entries > 256 ? 256 :
(int)image->colormap_entries; (int)image->colormap_entries;
/* NOTE: the caller must check for cmap != NULL and entries != 0 */ /* NOTE: the caller must check for cmap != NULL and entries != 0 */
const png_uint_32 format = image->format; const png_uint_32 format = image->format;
const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format); const int channels = PNG_IMAGE_SAMPLE_CHANNELS(format);
# if defined(PNG_FORMAT_BGR_SUPPORTED) &&\ # if defined(PNG_FORMAT_BGR_SUPPORTED) &&\
defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED) defined(PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED)
const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 && const int afirst = (format & PNG_FORMAT_FLAG_AFIRST) != 0 &&
(format & PNG_FORMAT_FLAG_ALPHA) != 0; (format & PNG_FORMAT_FLAG_ALPHA) != 0;
# else # else
# define afirst 0 # define afirst 0
# endif # endif
# ifdef PNG_FORMAT_BGR_SUPPORTED # ifdef PNG_FORMAT_BGR_SUPPORTED
const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0; const int bgr = (format & PNG_FORMAT_FLAG_BGR) != 0 ? 2 : 0;
# else # else
# define bgr 0 # define bgr 0
# endif # endif
int i, num_trans; int i, num_trans;
png_color palette[256]; png_color palette[256];
@ -1811,11 +1813,11 @@ png_image_set_PLTE(png_image_write_control *display)
if (channels >= 3) /* RGB */ if (channels >= 3) /* RGB */
{ {
palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 * palette[i].blue = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
entry[(2 ^ bgr)]); entry[(2 ^ bgr)]);
palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 * palette[i].green = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
entry[1]); entry[1]);
palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 * palette[i].red = (png_byte)PNG_sRGB_FROM_LINEAR(255 *
entry[bgr]); entry[bgr]);
} }
else /* Gray */ else /* Gray */
@ -1891,12 +1893,12 @@ png_image_set_PLTE(png_image_write_control *display)
} }
} }
# ifdef afirst # ifdef afirst
# undef afirst # undef afirst
# endif # endif
# ifdef bgr # ifdef bgr
# undef bgr # undef bgr
# 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);
@ -1924,10 +1926,10 @@ png_image_write_main(png_voidp argument)
int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA); int alpha = !colormap && (format & PNG_FORMAT_FLAG_ALPHA);
int write_16bit = linear && !colormap && (display->convert_to_8bit == 0); int write_16bit = linear && !colormap && (display->convert_to_8bit == 0);
# ifdef PNG_BENIGN_ERRORS_SUPPORTED # ifdef PNG_BENIGN_ERRORS_SUPPORTED
/* Make sure we error out on any bad situation */ /* Make sure we error out on any bad situation */
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. */
if (display->row_stride == 0) if (display->row_stride == 0)
@ -2006,23 +2008,23 @@ png_image_write_main(png_voidp argument)
png_set_swap(png_ptr); png_set_swap(png_ptr);
} }
# ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_BGR_SUPPORTED
if ((format & PNG_FORMAT_FLAG_BGR) != 0) if ((format & PNG_FORMAT_FLAG_BGR) != 0)
{ {
if (colormap == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0) if (colormap == 0 && (format & PNG_FORMAT_FLAG_COLOR) != 0)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
format &= ~PNG_FORMAT_FLAG_BGR; format &= ~PNG_FORMAT_FLAG_BGR;
} }
# endif # endif
# ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED # ifdef PNG_SIMPLIFIED_WRITE_AFIRST_SUPPORTED
if ((format & PNG_FORMAT_FLAG_AFIRST) != 0) if ((format & PNG_FORMAT_FLAG_AFIRST) != 0)
{ {
if (colormap == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0) if (colormap == 0 && (format & PNG_FORMAT_FLAG_ALPHA) != 0)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
format &= ~PNG_FORMAT_FLAG_AFIRST; format &= ~PNG_FORMAT_FLAG_AFIRST;
} }
# endif # endif
/* If there are 16 or fewer color-map entries we wrote a lower bit depth /* If there are 16 or fewer color-map entries we wrote a lower bit depth
* above, but the application data is still byte packed. * above, but the application data is still byte packed.
@ -2058,9 +2060,9 @@ png_image_write_main(png_voidp argument)
* it about 50 times. The speed-up in pngstest was about 10-20% of the * it about 50 times. The speed-up in pngstest was about 10-20% of the
* total (user) time on a heavily loaded system. * total (user) time on a heavily loaded system.
*/ */
#ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED # ifdef PNG_WRITE_CUSTOMIZE_COMPRESSION_SUPPORTED
png_set_compression_level(png_ptr, 3); png_set_compression_level(png_ptr, 3);
#endif # endif
} }
/* Check for the cases that currently require a pre-transform on the row /* Check for the cases that currently require a pre-transform on the row
@ -2223,6 +2225,6 @@ png_image_write_to_file(png_imagep image, const char *file_name,
else else
return 0; return 0;
} }
#endif /* STDIO */ # endif /* STDIO */
#endif /* SIMPLIFIED_WRITE */ #endif /* SIMPLIFIED_WRITE */
#endif /* WRITE */ #endif /* WRITE */