|
|
|
@ -1,7 +1,7 @@ |
|
|
|
|
|
|
|
|
|
|
|
/* pngwutil.c - utilities to write a PNG file
|
|
|
|
/* pngwutil.c - utilities to write a PNG file
|
|
|
|
* |
|
|
|
* |
|
|
|
* Last changed in libpng 1.2.15 January 5, 2007 |
|
|
|
* Last changed in libpng 1.2.20 Septhember 3, 2007 |
|
|
|
* For conditions of distribution and use, see copyright notice in png.h |
|
|
|
* For conditions of distribution and use, see copyright notice in png.h |
|
|
|
* Copyright (c) 1998-2007 Glenn Randers-Pehrson |
|
|
|
* Copyright (c) 1998-2007 Glenn Randers-Pehrson |
|
|
|
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
|
|
|
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) |
|
|
|
@ -182,7 +182,7 @@ png_text_compress(png_structp png_ptr, |
|
|
|
{ |
|
|
|
{ |
|
|
|
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
|
|
|
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
|
|
|
char msg[50]; |
|
|
|
char msg[50]; |
|
|
|
sprintf(msg, "Unknown compression type %d", compression); |
|
|
|
png_snprintf(msg, 50, "Unknown compression type %d", compression); |
|
|
|
png_warning(png_ptr, msg); |
|
|
|
png_warning(png_ptr, msg); |
|
|
|
#else |
|
|
|
#else |
|
|
|
png_warning(png_ptr, "Unknown compression type"); |
|
|
|
png_warning(png_ptr, "Unknown compression type"); |
|
|
|
@ -494,7 +494,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, |
|
|
|
buf[12] = (png_byte)interlace_type; |
|
|
|
buf[12] = (png_byte)interlace_type; |
|
|
|
|
|
|
|
|
|
|
|
/* write the chunk */ |
|
|
|
/* write the chunk */ |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13); |
|
|
|
png_write_chunk(png_ptr, png_IHDR, buf, (png_size_t)13); |
|
|
|
|
|
|
|
|
|
|
|
/* initialize zlib with PNG info */ |
|
|
|
/* initialize zlib with PNG info */ |
|
|
|
png_ptr->zstream.zalloc = png_zalloc; |
|
|
|
png_ptr->zstream.zalloc = png_zalloc; |
|
|
|
@ -523,9 +523,10 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height, |
|
|
|
png_ptr->zlib_window_bits = 15; |
|
|
|
png_ptr->zlib_window_bits = 15; |
|
|
|
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) |
|
|
|
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD)) |
|
|
|
png_ptr->zlib_method = 8; |
|
|
|
png_ptr->zlib_method = 8; |
|
|
|
deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, |
|
|
|
if (deflateInit2(&png_ptr->zstream, png_ptr->zlib_level, |
|
|
|
png_ptr->zlib_method, png_ptr->zlib_window_bits, |
|
|
|
png_ptr->zlib_method, png_ptr->zlib_window_bits, |
|
|
|
png_ptr->zlib_mem_level, png_ptr->zlib_strategy); |
|
|
|
png_ptr->zlib_mem_level, png_ptr->zlib_strategy) != Z_OK) |
|
|
|
|
|
|
|
png_error(png_ptr, "zlib failed to initialize compressor"); |
|
|
|
png_ptr->zstream.next_out = png_ptr->zbuf; |
|
|
|
png_ptr->zstream.next_out = png_ptr->zbuf; |
|
|
|
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
|
|
|
png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size; |
|
|
|
/* libpng is not interested in zstream.data_type */ |
|
|
|
/* libpng is not interested in zstream.data_type */ |
|
|
|
@ -577,7 +578,7 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal) |
|
|
|
png_ptr->num_palette = (png_uint_16)num_pal; |
|
|
|
png_ptr->num_palette = (png_uint_16)num_pal; |
|
|
|
png_debug1(3, "num_palette = %d\n", png_ptr->num_palette); |
|
|
|
png_debug1(3, "num_palette = %d\n", png_ptr->num_palette); |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_PLTE, num_pal * 3); |
|
|
|
png_write_chunk_start(png_ptr, png_PLTE, num_pal * 3); |
|
|
|
#ifndef PNG_NO_POINTER_INDEXING |
|
|
|
#ifndef PNG_NO_POINTER_INDEXING |
|
|
|
for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) |
|
|
|
for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++) |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -649,7 +650,7 @@ png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length) |
|
|
|
"Invalid zlib compression method or flags in IDAT"); |
|
|
|
"Invalid zlib compression method or flags in IDAT"); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length); |
|
|
|
png_write_chunk(png_ptr, png_IDAT, data, length); |
|
|
|
png_ptr->mode |= PNG_HAVE_IDAT; |
|
|
|
png_ptr->mode |= PNG_HAVE_IDAT; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -661,7 +662,7 @@ png_write_IEND(png_structp png_ptr) |
|
|
|
PNG_IEND; |
|
|
|
PNG_IEND; |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
png_debug(1, "in png_write_IEND\n"); |
|
|
|
png_debug(1, "in png_write_IEND\n"); |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_IEND, png_bytep_NULL, |
|
|
|
png_write_chunk(png_ptr, png_IEND, png_bytep_NULL, |
|
|
|
(png_size_t)0); |
|
|
|
(png_size_t)0); |
|
|
|
png_ptr->mode |= PNG_HAVE_IEND; |
|
|
|
png_ptr->mode |= PNG_HAVE_IEND; |
|
|
|
} |
|
|
|
} |
|
|
|
@ -682,7 +683,7 @@ png_write_gAMA(png_structp png_ptr, double file_gamma) |
|
|
|
/* file_gamma is saved in 1/100,000ths */ |
|
|
|
/* file_gamma is saved in 1/100,000ths */ |
|
|
|
igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5); |
|
|
|
igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5); |
|
|
|
png_save_uint_32(buf, igamma); |
|
|
|
png_save_uint_32(buf, igamma); |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); |
|
|
|
png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#ifdef PNG_FIXED_POINT_SUPPORTED |
|
|
|
#ifdef PNG_FIXED_POINT_SUPPORTED |
|
|
|
@ -697,7 +698,7 @@ png_write_gAMA_fixed(png_structp png_ptr, png_fixed_point file_gamma) |
|
|
|
png_debug(1, "in png_write_gAMA\n"); |
|
|
|
png_debug(1, "in png_write_gAMA\n"); |
|
|
|
/* file_gamma is saved in 1/100,000ths */ |
|
|
|
/* file_gamma is saved in 1/100,000ths */ |
|
|
|
png_save_uint_32(buf, (png_uint_32)file_gamma); |
|
|
|
png_save_uint_32(buf, (png_uint_32)file_gamma); |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4); |
|
|
|
png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
@ -717,7 +718,7 @@ png_write_sRGB(png_structp png_ptr, int srgb_intent) |
|
|
|
png_warning(png_ptr, |
|
|
|
png_warning(png_ptr, |
|
|
|
"Invalid sRGB rendering intent specified"); |
|
|
|
"Invalid sRGB rendering intent specified"); |
|
|
|
buf[0]=(png_byte)srgb_intent; |
|
|
|
buf[0]=(png_byte)srgb_intent; |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1); |
|
|
|
png_write_chunk(png_ptr, png_sRGB, buf, (png_size_t)1); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
@ -782,7 +783,7 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type, |
|
|
|
PNG_COMPRESSION_TYPE_BASE, &comp); |
|
|
|
PNG_COMPRESSION_TYPE_BASE, &comp); |
|
|
|
|
|
|
|
|
|
|
|
/* make sure we include the NULL after the name and the compression type */ |
|
|
|
/* make sure we include the NULL after the name and the compression type */ |
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_iCCP, |
|
|
|
png_write_chunk_start(png_ptr, png_iCCP, |
|
|
|
(png_uint_32)name_len+profile_len+2); |
|
|
|
(png_uint_32)name_len+profile_len+2); |
|
|
|
new_name[name_len+1]=0x00; |
|
|
|
new_name[name_len+1]=0x00; |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 2); |
|
|
|
@ -822,7 +823,7 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette) |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/* make sure we include the NULL after the name */ |
|
|
|
/* make sure we include the NULL after the name */ |
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_sPLT, |
|
|
|
png_write_chunk_start(png_ptr, png_sPLT, |
|
|
|
(png_uint_32)(name_len + 2 + palette_size)); |
|
|
|
(png_uint_32)(name_len + 2 + palette_size)); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 1); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, 1); |
|
|
|
@ -930,7 +931,7 @@ png_write_sBIT(png_structp png_ptr, png_color_8p sbit, int color_type) |
|
|
|
buf[size++] = sbit->alpha; |
|
|
|
buf[size++] = sbit->alpha; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size); |
|
|
|
png_write_chunk(png_ptr, png_sBIT, buf, size); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
@ -994,7 +995,7 @@ png_write_cHRM(png_structp png_ptr, double white_x, double white_y, |
|
|
|
itemp = (png_uint_32)(blue_y * 100000.0 + 0.5); |
|
|
|
itemp = (png_uint_32)(blue_y * 100000.0 + 0.5); |
|
|
|
png_save_uint_32(buf + 28, itemp); |
|
|
|
png_save_uint_32(buf + 28, itemp); |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); |
|
|
|
png_write_chunk(png_ptr, png_cHRM, buf, (png_size_t)32); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#ifdef PNG_FIXED_POINT_SUPPORTED |
|
|
|
#ifdef PNG_FIXED_POINT_SUPPORTED |
|
|
|
@ -1046,7 +1047,7 @@ png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x, |
|
|
|
png_save_uint_32(buf + 24, (png_uint_32)blue_x); |
|
|
|
png_save_uint_32(buf + 24, (png_uint_32)blue_x); |
|
|
|
png_save_uint_32(buf + 28, (png_uint_32)blue_y); |
|
|
|
png_save_uint_32(buf + 28, (png_uint_32)blue_y); |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32); |
|
|
|
png_write_chunk(png_ptr, png_cHRM, buf, (png_size_t)32); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
@ -1071,7 +1072,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, |
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
/* write the chunk out as it is */ |
|
|
|
/* write the chunk out as it is */ |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_tRNS, trans, (png_size_t)num_trans); |
|
|
|
png_write_chunk(png_ptr, png_tRNS, trans, (png_size_t)num_trans); |
|
|
|
} |
|
|
|
} |
|
|
|
else if (color_type == PNG_COLOR_TYPE_GRAY) |
|
|
|
else if (color_type == PNG_COLOR_TYPE_GRAY) |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -1083,7 +1084,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, |
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
png_save_uint_16(buf, tran->gray); |
|
|
|
png_save_uint_16(buf, tran->gray); |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2); |
|
|
|
png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)2); |
|
|
|
} |
|
|
|
} |
|
|
|
else if (color_type == PNG_COLOR_TYPE_RGB) |
|
|
|
else if (color_type == PNG_COLOR_TYPE_RGB) |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -1097,7 +1098,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran, |
|
|
|
"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; |
|
|
|
} |
|
|
|
} |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6); |
|
|
|
png_write_chunk(png_ptr, png_tRNS, buf, (png_size_t)6); |
|
|
|
} |
|
|
|
} |
|
|
|
else |
|
|
|
else |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -1130,7 +1131,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) |
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
buf[0] = back->index; |
|
|
|
buf[0] = back->index; |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1); |
|
|
|
png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)1); |
|
|
|
} |
|
|
|
} |
|
|
|
else if (color_type & PNG_COLOR_MASK_COLOR) |
|
|
|
else if (color_type & PNG_COLOR_MASK_COLOR) |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -1143,7 +1144,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) |
|
|
|
"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; |
|
|
|
} |
|
|
|
} |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6); |
|
|
|
png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)6); |
|
|
|
} |
|
|
|
} |
|
|
|
else |
|
|
|
else |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -1154,7 +1155,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type) |
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
png_save_uint_16(buf, back->gray); |
|
|
|
png_save_uint_16(buf, back->gray); |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2); |
|
|
|
png_write_chunk(png_ptr, png_bKGD, buf, (png_size_t)2); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
@ -1179,7 +1180,7 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist) |
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_hIST, (png_uint_32)(num_hist * 2)); |
|
|
|
png_write_chunk_start(png_ptr, png_hIST, (png_uint_32)(num_hist * 2)); |
|
|
|
for (i = 0; i < num_hist; i++) |
|
|
|
for (i = 0; i < num_hist; i++) |
|
|
|
{ |
|
|
|
{ |
|
|
|
png_save_uint_16(buf, hist[i]); |
|
|
|
png_save_uint_16(buf, hist[i]); |
|
|
|
@ -1230,12 +1231,14 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key) |
|
|
|
/* Replace non-printing characters with a blank and print a warning */ |
|
|
|
/* Replace non-printing characters with a blank and print a warning */ |
|
|
|
for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) |
|
|
|
for (kp = key, dp = *new_key; *kp != '\0'; kp++, dp++) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (*kp < 0x20 || (*kp > 0x7E && (png_byte)*kp < 0xA1)) |
|
|
|
if ((png_byte)*kp < 0x20 || |
|
|
|
|
|
|
|
((png_byte)*kp > 0x7E && (png_byte)*kp < 0xA1)) |
|
|
|
{ |
|
|
|
{ |
|
|
|
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
|
|
|
#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE) |
|
|
|
char msg[40]; |
|
|
|
char msg[40]; |
|
|
|
|
|
|
|
|
|
|
|
sprintf(msg, "invalid keyword character 0x%02X", *kp); |
|
|
|
png_snprintf(msg, 40, |
|
|
|
|
|
|
|
"invalid keyword character 0x%02X", (png_byte)*kp); |
|
|
|
png_warning(png_ptr, msg); |
|
|
|
png_warning(png_ptr, msg); |
|
|
|
#else |
|
|
|
#else |
|
|
|
png_warning(png_ptr, "invalid character in keyword"); |
|
|
|
png_warning(png_ptr, "invalid character in keyword"); |
|
|
|
@ -1343,7 +1346,7 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp text, |
|
|
|
text_len = png_strlen(text); |
|
|
|
text_len = png_strlen(text); |
|
|
|
|
|
|
|
|
|
|
|
/* make sure we include the 0 after the key */ |
|
|
|
/* make sure we include the 0 after the key */ |
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_tEXt, (png_uint_32)key_len+text_len+1); |
|
|
|
png_write_chunk_start(png_ptr, png_tEXt, (png_uint_32)key_len+text_len+1); |
|
|
|
/*
|
|
|
|
/*
|
|
|
|
* We leave it to the application to meet PNG-1.0 requirements on the |
|
|
|
* We leave it to the application to meet PNG-1.0 requirements on the |
|
|
|
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
|
|
|
* contents of the text. PNG-1.0 through PNG-1.2 discourage the use of |
|
|
|
@ -1396,17 +1399,17 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text, |
|
|
|
|
|
|
|
|
|
|
|
text_len = png_strlen(text); |
|
|
|
text_len = png_strlen(text); |
|
|
|
|
|
|
|
|
|
|
|
png_free(png_ptr, new_key); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* compute the compressed data; do it now for the length */ |
|
|
|
/* compute the compressed data; do it now for the length */ |
|
|
|
text_len = png_text_compress(png_ptr, text, text_len, compression, |
|
|
|
text_len = png_text_compress(png_ptr, text, text_len, compression, |
|
|
|
&comp); |
|
|
|
&comp); |
|
|
|
|
|
|
|
|
|
|
|
/* write start of chunk */ |
|
|
|
/* write start of chunk */ |
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_zTXt, (png_uint_32) |
|
|
|
png_write_chunk_start(png_ptr, png_zTXt, (png_uint_32) |
|
|
|
(key_len+text_len+2)); |
|
|
|
(key_len+text_len+2)); |
|
|
|
/* write key */ |
|
|
|
/* write key */ |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)key, key_len + 1); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1); |
|
|
|
|
|
|
|
png_free(png_ptr, new_key); |
|
|
|
|
|
|
|
|
|
|
|
buf[0] = (png_byte)compression; |
|
|
|
buf[0] = (png_byte)compression; |
|
|
|
/* write compression */ |
|
|
|
/* write compression */ |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1); |
|
|
|
@ -1469,7 +1472,7 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key, |
|
|
|
/* make sure we include the compression flag, the compression byte,
|
|
|
|
/* make sure we include the compression flag, the compression byte,
|
|
|
|
* and the NULs after the key, lang, and lang_key parts */ |
|
|
|
* and the NULs after the key, lang, and lang_key parts */ |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_iTXt, |
|
|
|
png_write_chunk_start(png_ptr, png_iTXt, |
|
|
|
(png_uint_32)( |
|
|
|
(png_uint_32)( |
|
|
|
5 /* comp byte, comp flag, terminators for key, lang and lang_key */ |
|
|
|
5 /* comp byte, comp flag, terminators for key, lang and lang_key */ |
|
|
|
+ key_len |
|
|
|
+ key_len |
|
|
|
@ -1526,10 +1529,9 @@ png_write_oFFs(png_structp png_ptr, png_int_32 x_offset, png_int_32 y_offset, |
|
|
|
png_save_int_32(buf + 4, y_offset); |
|
|
|
png_save_int_32(buf + 4, y_offset); |
|
|
|
buf[8] = (png_byte)unit_type; |
|
|
|
buf[8] = (png_byte)unit_type; |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_oFFs, buf, (png_size_t)9); |
|
|
|
png_write_chunk(png_ptr, png_oFFs, buf, (png_size_t)9); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
|
|
|
#if defined(PNG_WRITE_pCAL_SUPPORTED) |
|
|
|
/* write the pCAL chunk (described in the PNG extensions document) */ |
|
|
|
/* write the pCAL chunk (described in the PNG extensions document) */ |
|
|
|
void /* PRIVATE */ |
|
|
|
void /* PRIVATE */ |
|
|
|
@ -1568,7 +1570,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0, |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
png_debug1(3, "pCAL total length = %d\n", (int)total_len); |
|
|
|
png_debug1(3, "pCAL total length = %d\n", (int)total_len); |
|
|
|
png_write_chunk_start(png_ptr, (png_bytep)png_pCAL, (png_uint_32)total_len); |
|
|
|
png_write_chunk_start(png_ptr, png_pCAL, (png_uint_32)total_len); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len); |
|
|
|
png_write_chunk_data(png_ptr, (png_bytep)new_purpose, purpose_len); |
|
|
|
png_save_int_32(buf, X0); |
|
|
|
png_save_int_32(buf, X0); |
|
|
|
png_save_int_32(buf + 4, X1); |
|
|
|
png_save_int_32(buf + 4, X1); |
|
|
|
@ -1621,14 +1623,14 @@ png_write_sCAL(png_structp png_ptr, int unit, double width, double height) |
|
|
|
total_len += wc_len; |
|
|
|
total_len += wc_len; |
|
|
|
} |
|
|
|
} |
|
|
|
#else |
|
|
|
#else |
|
|
|
sprintf(buf + 1, "%12.12e", width); |
|
|
|
png_snprintf(buf + 1, 63, "%12.12e", width); |
|
|
|
total_len = 1 + png_strlen(buf + 1) + 1; |
|
|
|
total_len = 1 + png_strlen(buf + 1) + 1; |
|
|
|
sprintf(buf + total_len, "%12.12e", height); |
|
|
|
png_snprintf(buf + total_len, 64-total_len, "%12.12e", height); |
|
|
|
total_len += png_strlen(buf + total_len); |
|
|
|
total_len += png_strlen(buf + total_len); |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len); |
|
|
|
png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len); |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_sCAL, (png_bytep)buf, total_len); |
|
|
|
png_write_chunk(png_ptr, png_sCAL, (png_bytep)buf, total_len); |
|
|
|
} |
|
|
|
} |
|
|
|
#else |
|
|
|
#else |
|
|
|
#ifdef PNG_FIXED_POINT_SUPPORTED |
|
|
|
#ifdef PNG_FIXED_POINT_SUPPORTED |
|
|
|
@ -1658,7 +1660,7 @@ png_write_sCAL_s(png_structp png_ptr, int unit, png_charp width, |
|
|
|
png_memcpy(buf + wlen + 2, height, hlen); /* do NOT append the '\0' here */ |
|
|
|
png_memcpy(buf + wlen + 2, height, hlen); /* do NOT append the '\0' here */ |
|
|
|
|
|
|
|
|
|
|
|
png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len); |
|
|
|
png_debug1(3, "sCAL total length = %u\n", (unsigned int)total_len); |
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_sCAL, buf, total_len); |
|
|
|
png_write_chunk(png_ptr, png_sCAL, buf, total_len); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
@ -1684,7 +1686,7 @@ png_write_pHYs(png_structp png_ptr, png_uint_32 x_pixels_per_unit, |
|
|
|
png_save_uint_32(buf + 4, y_pixels_per_unit); |
|
|
|
png_save_uint_32(buf + 4, y_pixels_per_unit); |
|
|
|
buf[8] = (png_byte)unit_type; |
|
|
|
buf[8] = (png_byte)unit_type; |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9); |
|
|
|
png_write_chunk(png_ptr, png_pHYs, buf, (png_size_t)9); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
@ -1716,7 +1718,7 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time) |
|
|
|
buf[5] = mod_time->minute; |
|
|
|
buf[5] = mod_time->minute; |
|
|
|
buf[6] = mod_time->second; |
|
|
|
buf[6] = mod_time->second; |
|
|
|
|
|
|
|
|
|
|
|
png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7); |
|
|
|
png_write_chunk(png_ptr, png_tIME, buf, (png_size_t)7); |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
@ -1724,6 +1726,7 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time) |
|
|
|
void /* PRIVATE */ |
|
|
|
void /* PRIVATE */ |
|
|
|
png_write_start_row(png_structp png_ptr) |
|
|
|
png_write_start_row(png_structp png_ptr) |
|
|
|
{ |
|
|
|
{ |
|
|
|
|
|
|
|
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
|
|
|
#ifdef PNG_USE_LOCAL_ARRAYS |
|
|
|
#ifdef PNG_USE_LOCAL_ARRAYS |
|
|
|
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
|
|
|
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
|
|
|
|
|
|
|
|
|
|
|
@ -1738,6 +1741,7 @@ png_write_start_row(png_structp png_ptr) |
|
|
|
|
|
|
|
|
|
|
|
/* offset to next interlace block in the y direction */ |
|
|
|
/* offset to next interlace block in the y direction */ |
|
|
|
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
|
|
|
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
|
|
|
|
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
png_size_t buf_size; |
|
|
|
png_size_t buf_size; |
|
|
|
@ -1750,6 +1754,7 @@ png_write_start_row(png_structp png_ptr) |
|
|
|
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); |
|
|
|
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); |
|
|
|
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; |
|
|
|
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef PNG_NO_WRITE_FILTERING |
|
|
|
/* set up filtering buffer, if using this filter */ |
|
|
|
/* set up filtering buffer, if using this filter */ |
|
|
|
if (png_ptr->do_filter & PNG_FILTER_SUB) |
|
|
|
if (png_ptr->do_filter & PNG_FILTER_SUB) |
|
|
|
{ |
|
|
|
{ |
|
|
|
@ -1767,7 +1772,7 @@ png_write_start_row(png_structp png_ptr) |
|
|
|
|
|
|
|
|
|
|
|
if (png_ptr->do_filter & PNG_FILTER_UP) |
|
|
|
if (png_ptr->do_filter & PNG_FILTER_UP) |
|
|
|
{ |
|
|
|
{ |
|
|
|
png_ptr->up_row = (png_bytep )png_malloc(png_ptr, |
|
|
|
png_ptr->up_row = (png_bytep)png_malloc(png_ptr, |
|
|
|
(png_ptr->rowbytes + 1)); |
|
|
|
(png_ptr->rowbytes + 1)); |
|
|
|
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; |
|
|
|
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP; |
|
|
|
} |
|
|
|
} |
|
|
|
@ -1781,10 +1786,11 @@ png_write_start_row(png_structp png_ptr) |
|
|
|
|
|
|
|
|
|
|
|
if (png_ptr->do_filter & PNG_FILTER_PAETH) |
|
|
|
if (png_ptr->do_filter & PNG_FILTER_PAETH) |
|
|
|
{ |
|
|
|
{ |
|
|
|
png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr, |
|
|
|
png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr, |
|
|
|
(png_ptr->rowbytes + 1)); |
|
|
|
(png_ptr->rowbytes + 1)); |
|
|
|
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; |
|
|
|
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
#endif /* PNG_NO_WRITE_FILTERING */ |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
|
|
|
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
|
|
|
@ -1818,6 +1824,7 @@ png_write_start_row(png_structp png_ptr) |
|
|
|
void /* PRIVATE */ |
|
|
|
void /* PRIVATE */ |
|
|
|
png_write_finish_row(png_structp png_ptr) |
|
|
|
png_write_finish_row(png_structp png_ptr) |
|
|
|
{ |
|
|
|
{ |
|
|
|
|
|
|
|
#ifdef PNG_WRITE_INTERLACING_SUPPORTED |
|
|
|
#ifdef PNG_USE_LOCAL_ARRAYS |
|
|
|
#ifdef PNG_USE_LOCAL_ARRAYS |
|
|
|
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
|
|
|
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ |
|
|
|
|
|
|
|
|
|
|
|
@ -1832,6 +1839,7 @@ png_write_finish_row(png_structp png_ptr) |
|
|
|
|
|
|
|
|
|
|
|
/* offset to next interlace block in the y direction */ |
|
|
|
/* offset to next interlace block in the y direction */ |
|
|
|
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
|
|
|
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2}; |
|
|
|
|
|
|
|
#endif |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
int ret; |
|
|
|
int ret; |
|
|
|
@ -2106,7 +2114,9 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass) |
|
|
|
void /* PRIVATE */ |
|
|
|
void /* PRIVATE */ |
|
|
|
png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
|
|
|
png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
|
|
|
{ |
|
|
|
{ |
|
|
|
png_bytep prev_row, best_row, row_buf; |
|
|
|
png_bytep best_row; |
|
|
|
|
|
|
|
#ifndef PNG_NO_WRITE_FILTER |
|
|
|
|
|
|
|
png_bytep prev_row, row_buf; |
|
|
|
png_uint_32 mins, bpp; |
|
|
|
png_uint_32 mins, bpp; |
|
|
|
png_byte filter_to_do = png_ptr->do_filter; |
|
|
|
png_byte filter_to_do = png_ptr->do_filter; |
|
|
|
png_uint_32 row_bytes = row_info->rowbytes; |
|
|
|
png_uint_32 row_bytes = row_info->rowbytes; |
|
|
|
@ -2119,7 +2129,10 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
|
|
|
bpp = (row_info->pixel_depth + 7) >> 3; |
|
|
|
bpp = (row_info->pixel_depth + 7) >> 3; |
|
|
|
|
|
|
|
|
|
|
|
prev_row = png_ptr->prev_row; |
|
|
|
prev_row = png_ptr->prev_row; |
|
|
|
best_row = row_buf = png_ptr->row_buf; |
|
|
|
#endif |
|
|
|
|
|
|
|
best_row = png_ptr->row_buf; |
|
|
|
|
|
|
|
#ifndef PNG_NO_WRITE_FILTER |
|
|
|
|
|
|
|
row_buf = best_row; |
|
|
|
mins = PNG_MAXSUM; |
|
|
|
mins = PNG_MAXSUM; |
|
|
|
|
|
|
|
|
|
|
|
/* The prediction method we use is to find which method provides the
|
|
|
|
/* The prediction method we use is to find which method provides the
|
|
|
|
@ -2694,11 +2707,12 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
|
|
|
best_row = png_ptr->paeth_row; |
|
|
|
best_row = png_ptr->paeth_row; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
#endif /* PNG_NO_WRITE_FILTER */ |
|
|
|
/* Do the actual writing of the filtered row data from the chosen filter. */ |
|
|
|
/* Do the actual writing of the filtered row data from the chosen filter. */ |
|
|
|
|
|
|
|
|
|
|
|
png_write_filtered_row(png_ptr, best_row); |
|
|
|
png_write_filtered_row(png_ptr, best_row); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef PNG_NO_WRITE_FILTER |
|
|
|
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
|
|
|
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) |
|
|
|
/* Save the type of filter we picked this time for future calculations */ |
|
|
|
/* Save the type of filter we picked this time for future calculations */ |
|
|
|
if (png_ptr->num_prev_filters > 0) |
|
|
|
if (png_ptr->num_prev_filters > 0) |
|
|
|
@ -2711,6 +2725,7 @@ png_write_find_filter(png_structp png_ptr, png_row_infop row_info) |
|
|
|
png_ptr->prev_filters[j] = best_row[0]; |
|
|
|
png_ptr->prev_filters[j] = best_row[0]; |
|
|
|
} |
|
|
|
} |
|
|
|
#endif |
|
|
|
#endif |
|
|
|
|
|
|
|
#endif /* PNG_NO_WRITE_FILTER */ |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Michael R Sweet
18 years ago