summaryrefslogtreecommitdiff
path: root/png/pngwutil.c
diff options
context:
space:
mode:
Diffstat (limited to 'png/pngwutil.c')
-rw-r--r--png/pngwutil.c105
1 files changed, 60 insertions, 45 deletions
diff --git a/png/pngwutil.c b/png/pngwutil.c
index e108c6106..fef38aef9 100644
--- a/png/pngwutil.c
+++ b/png/pngwutil.c
@@ -1,7 +1,7 @@
/* 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
* Copyright (c) 1998-2007 Glenn Randers-Pehrson
* (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)
char msg[50];
- sprintf(msg, "Unknown compression type %d", compression);
+ png_snprintf(msg, 50, "Unknown compression type %d", compression);
png_warning(png_ptr, msg);
#else
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;
/* 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 */
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;
if (!(png_ptr->flags & PNG_FLAG_ZLIB_CUSTOM_METHOD))
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_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.avail_out = (uInt)png_ptr->zbuf_size;
/* 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_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
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");
}
- 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;
}
@@ -661,7 +662,7 @@ png_write_IEND(png_structp png_ptr)
PNG_IEND;
#endif
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_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 */
igamma = (png_uint_32)(file_gamma * 100000.0 + 0.5);
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
#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");
/* file_gamma is saved in 1/100,000ths */
png_save_uint_32(buf, (png_uint_32)file_gamma);
- png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
+ png_write_chunk(png_ptr, png_gAMA, buf, (png_size_t)4);
}
#endif
#endif
@@ -717,7 +718,7 @@ png_write_sRGB(png_structp png_ptr, int srgb_intent)
png_warning(png_ptr,
"Invalid sRGB rendering intent specified");
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
@@ -782,7 +783,7 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
PNG_COMPRESSION_TYPE_BASE, &comp);
/* 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);
new_name[name_len+1]=0x00;
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 */
- 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_write_chunk_data(png_ptr, (png_bytep)new_name, name_len + 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;
}
- png_write_chunk(png_ptr, (png_bytep)png_sBIT, buf, size);
+ png_write_chunk(png_ptr, png_sBIT, buf, size);
}
#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);
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
#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 + 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
@@ -1071,7 +1072,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
return;
}
/* 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)
{
@@ -1083,7 +1084,7 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
return;
}
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)
{
@@ -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");
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
{
@@ -1130,7 +1131,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
return;
}
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)
{
@@ -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");
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
{
@@ -1154,7 +1155,7 @@ png_write_bKGD(png_structp png_ptr, png_color_16p back, int color_type)
return;
}
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
@@ -1179,7 +1180,7 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
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++)
{
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 */
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)
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);
#else
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);
/* 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
* 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);
- png_free(png_ptr, new_key);
-
/* compute the compressed data; do it now for the length */
text_len = png_text_compress(png_ptr, text, text_len, compression,
&comp);
/* 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));
/* 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;
/* write compression */
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,
* 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)(
5 /* comp byte, comp flag, terminators for key, lang and lang_key */
+ 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);
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
-
#if defined(PNG_WRITE_pCAL_SUPPORTED)
/* write the pCAL chunk (described in the PNG extensions document) */
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_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_save_int_32(buf, X0);
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;
}
#else
- sprintf(buf + 1, "%12.12e", width);
+ png_snprintf(buf + 1, 63, "%12.12e", width);
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);
#endif
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
#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_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
@@ -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);
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
@@ -1716,7 +1718,7 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time)
buf[5] = mod_time->minute;
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
@@ -1724,6 +1726,7 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time)
void /* PRIVATE */
png_write_start_row(png_structp png_ptr)
{
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
#ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
@@ -1739,6 +1742,7 @@ png_write_start_row(png_structp png_ptr)
/* offset to next interlace block in the y direction */
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif
+#endif
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[0] = PNG_FILTER_VALUE_NONE;
+#ifndef PNG_NO_WRITE_FILTERING
/* set up filtering buffer, if using this filter */
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)
{
- 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->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)
{
- 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->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
}
+#endif /* PNG_NO_WRITE_FILTERING */
}
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
@@ -1818,6 +1824,7 @@ png_write_start_row(png_structp png_ptr)
void /* PRIVATE */
png_write_finish_row(png_structp png_ptr)
{
+#ifdef PNG_WRITE_INTERLACING_SUPPORTED
#ifdef PNG_USE_LOCAL_ARRAYS
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
@@ -1833,6 +1840,7 @@ png_write_finish_row(png_structp png_ptr)
/* offset to next interlace block in the y direction */
int png_pass_yinc[7] = {8, 8, 8, 4, 4, 2, 2};
#endif
+#endif
int ret;
@@ -2106,7 +2114,9 @@ png_do_write_interlace(png_row_infop row_info, png_bytep row, int pass)
void /* PRIVATE */
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_byte filter_to_do = png_ptr->do_filter;
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;
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;
/* 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;
}
}
-
+#endif /* PNG_NO_WRITE_FILTER */
/* Do the actual writing of the filtered row data from the chosen filter. */
png_write_filtered_row(png_ptr, best_row);
+#ifndef PNG_NO_WRITE_FILTER
#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
/* Save the type of filter we picked this time for future calculations */
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];
}
#endif
+#endif /* PNG_NO_WRITE_FILTER */
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-08 09:04:29 +0000