mirror of
https://git.code.sf.net/p/libpng/code.git
synced 2025-07-10 18:04:09 +02:00
Imported from libpng-1.4.0beta20.tar
This commit is contained in:
Glenn Randers-Pehrson
304
pngwutil.c
304
pngwutil.c
@@ -1,9 +1,9 @@
|
||||
|
||||
/* pngwutil.c - utilities to write a PNG file
|
||||
*
|
||||
* Last changed in libpng 1.4.0 May 15, 2007
|
||||
* Last changed in libpng 1.4.0 [July 10, 2008]
|
||||
* For conditions of distribution and use, see copyright notice in png.h
|
||||
* Copyright (c) 1998-2007 Glenn Randers-Pehrson
|
||||
* Copyright (c) 1998-2008 Glenn Randers-Pehrson
|
||||
* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
|
||||
* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
|
||||
*/
|
||||
@@ -70,7 +70,7 @@ png_write_sig(png_structp png_ptr)
|
||||
/* write the rest of the 8 byte signature */
|
||||
png_write_data(png_ptr, &png_signature[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;
|
||||
}
|
||||
|
||||
@@ -87,9 +87,9 @@ void PNGAPI
|
||||
png_write_chunk(png_structp png_ptr, png_bytep chunk_name,
|
||||
png_bytep data, png_size_t length)
|
||||
{
|
||||
if(png_ptr == NULL) return;
|
||||
if (png_ptr == NULL) return;
|
||||
png_write_chunk_start(png_ptr, chunk_name, (png_uint_32)length);
|
||||
png_write_chunk_data(png_ptr, data, length);
|
||||
png_write_chunk_data(png_ptr, data, (png_size_t)length);
|
||||
png_write_chunk_end(png_ptr);
|
||||
}
|
||||
|
||||
@@ -102,8 +102,6 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
|
||||
png_uint_32 length)
|
||||
{
|
||||
png_byte buf[8];
|
||||
png_debug2(0, "Writing %s chunk, length = %lu\n", chunk_name,
|
||||
(unsigned long)length);
|
||||
|
||||
#ifdef PNG_IO_STATE_SUPPORTED
|
||||
/* Inform the I/O callback that the chunk header is being written.
|
||||
@@ -112,14 +110,16 @@ png_write_chunk_start(png_structp png_ptr, png_bytep chunk_name,
|
||||
png_ptr->io_state = PNG_IO_WRITING | PNG_IO_CHUNK_HDR;
|
||||
#endif
|
||||
|
||||
png_debug2(0, "Writing %s chunk, length = %lu\n", chunk_name,
|
||||
(unsigned long)length);
|
||||
if (png_ptr == NULL) return;
|
||||
|
||||
/* write the length and the chunk name */
|
||||
png_save_uint_32(buf, length);
|
||||
png_memcpy(buf + 4, chunk_name, 4);
|
||||
png_write_data(png_ptr, buf, 8);
|
||||
|
||||
png_write_data(png_ptr, buf, (png_size_t)8);
|
||||
/* put the chunk name into png_ptr->chunk_name */
|
||||
png_memcpy(png_ptr->chunk_name, chunk_name, 4);
|
||||
|
||||
/* reset the crc and run it over the chunk name */
|
||||
png_reset_crc(png_ptr);
|
||||
png_calculate_crc(png_ptr, chunk_name, 4);
|
||||
@@ -141,7 +141,7 @@ void PNGAPI
|
||||
png_write_chunk_data(png_structp png_ptr, png_bytep data, png_size_t length)
|
||||
{
|
||||
/* write the data, and run the CRC over it */
|
||||
if(png_ptr == NULL) return;
|
||||
if (png_ptr == NULL) return;
|
||||
if (data != NULL && length > 0)
|
||||
{
|
||||
png_write_data(png_ptr, data, length);
|
||||
@@ -158,6 +158,8 @@ png_write_chunk_end(png_structp png_ptr)
|
||||
{
|
||||
png_byte buf[4];
|
||||
|
||||
if (png_ptr == NULL) return;
|
||||
|
||||
#ifdef PNG_IO_STATE_SUPPORTED
|
||||
/* Inform the I/O callback that the chunk CRC is being written.
|
||||
* PNG_IO_CHUNK_CRC requires a single I/O function call.
|
||||
@@ -168,7 +170,7 @@ png_write_chunk_end(png_structp png_ptr)
|
||||
/* write the crc in a single operation */
|
||||
png_save_uint_32(buf, png_ptr->crc);
|
||||
|
||||
png_write_data(png_ptr, buf, 4);
|
||||
png_write_data(png_ptr, buf, (png_size_t)4);
|
||||
}
|
||||
|
||||
#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_iCCP_SUPPORTED)
|
||||
@@ -212,9 +214,9 @@ png_text_compress(png_structp png_ptr,
|
||||
|
||||
if (compression >= PNG_TEXT_COMPRESSION_LAST)
|
||||
{
|
||||
#ifndef PNG_NO_STDIO
|
||||
#if !defined(PNG_NO_STDIO)
|
||||
char msg[50];
|
||||
png_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");
|
||||
@@ -271,19 +273,22 @@ png_text_compress(png_structp png_ptr,
|
||||
|
||||
old_ptr = comp->output_ptr;
|
||||
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
||||
(png_size_t)(comp->max_output_ptr * sizeof(png_charpp)));
|
||||
(png_size_t)
|
||||
(comp->max_output_ptr * png_sizeof(png_charpp)));
|
||||
png_memcpy(comp->output_ptr, old_ptr, old_max
|
||||
* sizeof(png_charp));
|
||||
* png_sizeof(png_charp));
|
||||
png_free(png_ptr, old_ptr);
|
||||
}
|
||||
else
|
||||
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
||||
(png_size_t)(comp->max_output_ptr * sizeof(png_charp)));
|
||||
(png_size_t)
|
||||
(comp->max_output_ptr * png_sizeof(png_charp)));
|
||||
}
|
||||
|
||||
/* save the data */
|
||||
comp->output_ptr[comp->num_output_ptr] =
|
||||
(png_charp)png_malloc(png_ptr, png_ptr->zbuf_size);
|
||||
(png_charp)png_malloc(png_ptr,
|
||||
png_ptr->zbuf_size);
|
||||
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
|
||||
png_ptr->zbuf_size);
|
||||
comp->num_output_ptr++;
|
||||
@@ -320,19 +325,22 @@ png_text_compress(png_structp png_ptr,
|
||||
old_ptr = comp->output_ptr;
|
||||
/* This could be optimized to realloc() */
|
||||
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
||||
(png_size_t)(comp->max_output_ptr * sizeof(png_charpp)));
|
||||
(png_size_t)(comp->max_output_ptr *
|
||||
png_sizeof(png_charp)));
|
||||
png_memcpy(comp->output_ptr, old_ptr,
|
||||
old_max * sizeof(png_charp));
|
||||
old_max * png_sizeof(png_charp));
|
||||
png_free(png_ptr, old_ptr);
|
||||
}
|
||||
else
|
||||
comp->output_ptr = (png_charpp)png_malloc(png_ptr,
|
||||
(png_size_t)(comp->max_output_ptr * sizeof(png_charp)));
|
||||
(png_size_t)(comp->max_output_ptr *
|
||||
png_sizeof(png_charp)));
|
||||
}
|
||||
|
||||
/* save off the data */
|
||||
comp->output_ptr[comp->num_output_ptr] =
|
||||
(png_charp)png_malloc(png_ptr, png_ptr->zbuf_size);
|
||||
(png_charp)png_malloc(png_ptr,
|
||||
(png_size_t)png_ptr->zbuf_size);
|
||||
png_memcpy(comp->output_ptr[comp->num_output_ptr], png_ptr->zbuf,
|
||||
png_ptr->zbuf_size);
|
||||
comp->num_output_ptr++;
|
||||
@@ -377,8 +385,8 @@ png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
|
||||
/* write saved output buffers, if any */
|
||||
for (i = 0; i < comp->num_output_ptr; i++)
|
||||
{
|
||||
png_write_chunk_data(png_ptr,(png_bytep)comp->output_ptr[i],
|
||||
png_ptr->zbuf_size);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)comp->output_ptr[i],
|
||||
(png_size_t)png_ptr->zbuf_size);
|
||||
png_free(png_ptr, comp->output_ptr[i]);
|
||||
comp->output_ptr[i]=NULL;
|
||||
}
|
||||
@@ -388,7 +396,7 @@ png_write_compressed_data_out(png_structp png_ptr, compression_state *comp)
|
||||
/* write anything left in zbuf */
|
||||
if (png_ptr->zstream.avail_out < (png_uint_32)png_ptr->zbuf_size)
|
||||
png_write_chunk_data(png_ptr, png_ptr->zbuf,
|
||||
png_ptr->zbuf_size - png_ptr->zstream.avail_out);
|
||||
(png_size_t)(png_ptr->zbuf_size - png_ptr->zstream.avail_out));
|
||||
|
||||
/* reset zlib for another zTXt/iTXt or image data */
|
||||
deflateReset(&png_ptr->zstream);
|
||||
@@ -408,6 +416,8 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_IHDR;
|
||||
#endif
|
||||
int ret;
|
||||
|
||||
png_byte buf[13]; /* buffer to store the IHDR info */
|
||||
|
||||
png_debug(1, "in png_write_IHDR\n");
|
||||
@@ -422,7 +432,7 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
|
||||
case 4:
|
||||
case 8:
|
||||
case 16: png_ptr->channels = 1; break;
|
||||
default: png_error(png_ptr,"Invalid bit depth for grayscale image");
|
||||
default: png_error(png_ptr, "Invalid bit depth for grayscale image");
|
||||
}
|
||||
break;
|
||||
case PNG_COLOR_TYPE_RGB:
|
||||
@@ -522,7 +532,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, 13);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
|
||||
|
||||
/* initialize zlib with PNG info */
|
||||
png_ptr->zstream.zalloc = png_zalloc;
|
||||
@@ -551,9 +561,19 @@ 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,
|
||||
png_ptr->zlib_method, png_ptr->zlib_window_bits,
|
||||
png_ptr->zlib_mem_level, png_ptr->zlib_strategy);
|
||||
ret = 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);
|
||||
if (ret != Z_OK)
|
||||
{
|
||||
if (ret == Z_VERSION_ERROR) png_error(png_ptr,
|
||||
"zlib failed to initialize compressor -- version error");
|
||||
if (ret == Z_STREAM_ERROR) png_error(png_ptr,
|
||||
"zlib failed to initialize compressor -- stream error");
|
||||
if (ret == Z_MEM_ERROR) png_error(png_ptr,
|
||||
"zlib failed to initialize compressor -- mem error");
|
||||
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 */
|
||||
@@ -605,14 +625,15 @@ 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_bytep)png_PLTE,
|
||||
(png_uint_32)(num_pal * 3));
|
||||
#ifndef PNG_NO_POINTER_INDEXING
|
||||
for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
|
||||
{
|
||||
buf[0] = pal_ptr->red;
|
||||
buf[1] = pal_ptr->green;
|
||||
buf[2] = pal_ptr->blue;
|
||||
png_write_chunk_data(png_ptr, buf, 3);
|
||||
png_write_chunk_data(png_ptr, buf, (png_size_t)3);
|
||||
}
|
||||
#else
|
||||
/* This is a little slower but some buggy compilers need to do this instead */
|
||||
@@ -622,7 +643,7 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
|
||||
buf[0] = pal_ptr[i].red;
|
||||
buf[1] = pal_ptr[i].green;
|
||||
buf[2] = pal_ptr[i].blue;
|
||||
png_write_chunk_data(png_ptr, buf, 3);
|
||||
png_write_chunk_data(png_ptr, buf, (png_size_t)3);
|
||||
}
|
||||
#endif
|
||||
png_write_chunk_end(png_ptr);
|
||||
@@ -689,7 +710,8 @@ 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, NULL, 0);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_IEND, NULL,
|
||||
(png_size_t)0);
|
||||
png_ptr->mode |= PNG_HAVE_IEND;
|
||||
}
|
||||
|
||||
@@ -709,7 +731,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, 4);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
|
||||
}
|
||||
#endif
|
||||
#ifdef PNG_FIXED_POINT_SUPPORTED
|
||||
@@ -724,7 +746,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, 4);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_gAMA, buf, (png_size_t)4);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -740,11 +762,11 @@ png_write_sRGB(png_structp png_ptr, int srgb_intent)
|
||||
png_byte buf[1];
|
||||
|
||||
png_debug(1, "in png_write_sRGB\n");
|
||||
if(srgb_intent >= PNG_sRGB_INTENT_LAST)
|
||||
if (srgb_intent >= PNG_sRGB_INTENT_LAST)
|
||||
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, 1);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_sRGB, buf, (png_size_t)1);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -785,34 +807,35 @@ png_write_iCCP(png_structp png_ptr, png_charp name, int compression_type,
|
||||
|
||||
if (profile_len > 3)
|
||||
embedded_profile_len =
|
||||
((*( (png_bytep)profile ))<<24) |
|
||||
((*( (png_bytep)profile+1))<<16) |
|
||||
((*( (png_bytep)profile+2))<< 8) |
|
||||
((*( (png_bytep)profile+3)) );
|
||||
((*( (png_bytep)profile ))<<24) |
|
||||
((*( (png_bytep)profile + 1))<<16) |
|
||||
((*( (png_bytep)profile + 2))<< 8) |
|
||||
((*( (png_bytep)profile + 3)) );
|
||||
|
||||
if (profile_len < embedded_profile_len)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Embedded profile length too large in iCCP chunk");
|
||||
return;
|
||||
}
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Embedded profile length too large in iCCP chunk");
|
||||
return;
|
||||
}
|
||||
|
||||
if (profile_len > embedded_profile_len)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Truncating profile to actual length in iCCP chunk");
|
||||
profile_len = embedded_profile_len;
|
||||
}
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Truncating profile to actual length in iCCP chunk");
|
||||
profile_len = embedded_profile_len;
|
||||
}
|
||||
|
||||
if (profile_len)
|
||||
profile_len = png_text_compress(png_ptr, profile,
|
||||
(png_size_t)profile_len, PNG_COMPRESSION_TYPE_BASE, &comp);
|
||||
profile_len = png_text_compress(png_ptr, profile,
|
||||
(png_size_t)profile_len, 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_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);
|
||||
(png_uint_32)(name_len + profile_len + 2));
|
||||
new_name[name_len + 1] = 0x00;
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_name,
|
||||
(png_size_t)(name_len + 2));
|
||||
|
||||
if (profile_len)
|
||||
png_write_compressed_data_out(png_ptr, &comp);
|
||||
@@ -850,13 +873,14 @@ 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_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);
|
||||
(png_uint_32)(name_len + 2 + palette_size));
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_name,
|
||||
(png_size_t)(name_len + 1));
|
||||
png_write_chunk_data(png_ptr, (png_bytep)&spalette->depth, (png_size_t)1);
|
||||
|
||||
/* loop through each palette entry, writing appropriately */
|
||||
#ifndef PNG_NO_POINTER_INDEXING
|
||||
for (ep = spalette->entries; ep<spalette->entries+spalette->nentries; ep++)
|
||||
for (ep = spalette->entries; ep<spalette->entries + spalette->nentries; ep++)
|
||||
{
|
||||
if (spalette->depth == 8)
|
||||
{
|
||||
@@ -874,7 +898,7 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
|
||||
png_save_uint_16(entrybuf + 6, ep->alpha);
|
||||
png_save_uint_16(entrybuf + 8, ep->frequency);
|
||||
}
|
||||
png_write_chunk_data(png_ptr, entrybuf, entry_size);
|
||||
png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
|
||||
}
|
||||
#else
|
||||
ep=spalette->entries;
|
||||
@@ -896,7 +920,7 @@ png_write_sPLT(png_structp png_ptr, png_sPLT_tp spalette)
|
||||
png_save_uint_16(entrybuf + 6, ep[i].alpha);
|
||||
png_save_uint_16(entrybuf + 8, ep[i].frequency);
|
||||
}
|
||||
png_write_chunk_data(png_ptr, entrybuf, entry_size);
|
||||
png_write_chunk_data(png_ptr, entrybuf, (png_size_t)entry_size);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -982,7 +1006,7 @@ png_write_cHRM(png_structp png_ptr, double white_x, double white_y,
|
||||
{
|
||||
png_warning(png_ptr, "Invalid cHRM white point specified");
|
||||
#if !defined(PNG_NO_CONSOLE_IO)
|
||||
fprintf(stderr,"white_x=%f, white_y=%f\n",white_x, white_y);
|
||||
fprintf(stderr, "white_x=%f, white_y=%f\n", white_x, white_y);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
@@ -1021,7 +1045,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, 32);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
|
||||
}
|
||||
#endif
|
||||
#ifdef PNG_FIXED_POINT_SUPPORTED
|
||||
@@ -1042,7 +1066,7 @@ png_write_cHRM_fixed(png_structp png_ptr, png_fixed_point white_x,
|
||||
{
|
||||
png_warning(png_ptr, "Invalid fixed cHRM white point specified");
|
||||
#if !defined(PNG_NO_CONSOLE_IO)
|
||||
fprintf(stderr,"white_x=%ld, white_y=%ld\n",(unsigned long)white_x,
|
||||
fprintf(stderr, "white_x=%ld, white_y=%ld\n", (unsigned long)white_x,
|
||||
(unsigned long)white_y);
|
||||
#endif
|
||||
return;
|
||||
@@ -1074,7 +1098,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, 32);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_cHRM, buf, (png_size_t)32);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
@@ -1095,24 +1119,24 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
|
||||
{
|
||||
if (num_trans <= 0 || num_trans > (int)png_ptr->num_palette)
|
||||
{
|
||||
png_warning(png_ptr,"Invalid number of transparent colors specified");
|
||||
png_warning(png_ptr, "Invalid number of transparent colors specified");
|
||||
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_bytep)png_tRNS, trans,
|
||||
(png_size_t)num_trans);
|
||||
}
|
||||
else if (color_type == PNG_COLOR_TYPE_GRAY)
|
||||
{
|
||||
/* one 16 bit value */
|
||||
if(tran->gray >= (1 << png_ptr->bit_depth))
|
||||
if (tran->gray >= (1 << png_ptr->bit_depth))
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to write tRNS chunk out-of-range for bit_depth");
|
||||
return;
|
||||
}
|
||||
png_save_uint_16(buf, tran->gray);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, 2);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)2);
|
||||
}
|
||||
else if (color_type == PNG_COLOR_TYPE_RGB)
|
||||
{
|
||||
@@ -1120,13 +1144,13 @@ png_write_tRNS(png_structp png_ptr, png_bytep trans, png_color_16p tran,
|
||||
png_save_uint_16(buf, tran->red);
|
||||
png_save_uint_16(buf + 2, tran->green);
|
||||
png_save_uint_16(buf + 4, tran->blue);
|
||||
if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
||||
if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
||||
{
|
||||
png_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;
|
||||
}
|
||||
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, 6);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_tRNS, buf, (png_size_t)6);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1159,31 +1183,31 @@ 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, 1);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)1);
|
||||
}
|
||||
else if (color_type & PNG_COLOR_MASK_COLOR)
|
||||
{
|
||||
png_save_uint_16(buf, back->red);
|
||||
png_save_uint_16(buf + 2, back->green);
|
||||
png_save_uint_16(buf + 4, back->blue);
|
||||
if(png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
||||
if (png_ptr->bit_depth == 8 && (buf[0] | buf[2] | buf[4]))
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to write 16-bit bKGD chunk when bit_depth is 8");
|
||||
return;
|
||||
}
|
||||
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, 6);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)6);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(back->gray >= (1 << png_ptr->bit_depth))
|
||||
if (back->gray >= (1 << png_ptr->bit_depth))
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to write bKGD chunk out-of-range for bit_depth");
|
||||
return;
|
||||
}
|
||||
png_save_uint_16(buf, back->gray);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, 2);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_bKGD, buf, (png_size_t)2);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -1209,11 +1233,11 @@ png_write_hIST(png_structp png_ptr, png_uint_16p hist, int num_hist)
|
||||
}
|
||||
|
||||
png_write_chunk_start(png_ptr, (png_bytep)png_hIST,
|
||||
(png_uint_32)(num_hist * 2));
|
||||
(png_uint_32)(num_hist * 2));
|
||||
for (i = 0; i < num_hist; i++)
|
||||
{
|
||||
png_save_uint_16(buf, hist[i]);
|
||||
png_write_chunk_data(png_ptr, buf, 2);
|
||||
png_write_chunk_data(png_ptr, buf, (png_size_t)2);
|
||||
}
|
||||
png_write_chunk_end(png_ptr);
|
||||
}
|
||||
@@ -1245,27 +1269,29 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
|
||||
if (key == NULL || (key_len = png_strlen(key)) == 0)
|
||||
{
|
||||
png_warning(png_ptr, "zero length keyword");
|
||||
return 0;
|
||||
return ((png_size_t)0);
|
||||
}
|
||||
|
||||
png_debug1(2, "Keyword to be checked is '%s'\n", key);
|
||||
|
||||
*new_key = (png_charp)png_malloc_warn(png_ptr, key_len + 2);
|
||||
*new_key = (png_charp)png_malloc_warn(png_ptr, (png_uint_32)(key_len + 2));
|
||||
if (*new_key == NULL)
|
||||
{
|
||||
png_warning(png_ptr, "Out of memory while procesing keyword");
|
||||
return 0;
|
||||
return ((png_size_t)0);
|
||||
}
|
||||
|
||||
/* 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))
|
||||
{
|
||||
#ifndef PNG_NO_STDIO
|
||||
#if !defined(PNG_NO_STDIO)
|
||||
char msg[40];
|
||||
|
||||
png_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");
|
||||
@@ -1327,7 +1353,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
|
||||
}
|
||||
}
|
||||
*dp = '\0';
|
||||
if(kwarn)
|
||||
if (kwarn)
|
||||
png_warning(png_ptr, "extra interior spaces removed from keyword");
|
||||
|
||||
if (key_len == 0)
|
||||
@@ -1340,7 +1366,7 @@ png_check_keyword(png_structp png_ptr, png_charp key, png_charpp new_key)
|
||||
if (key_len > 79)
|
||||
{
|
||||
png_warning(png_ptr, "keyword length must be 1 - 79 characters");
|
||||
(*new_key)[79] = '\0';
|
||||
new_key[79] = '\0';
|
||||
key_len = 79;
|
||||
}
|
||||
|
||||
@@ -1374,16 +1400,17 @@ png_write_tEXt(png_structp png_ptr, png_charp key, png_charp 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_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
|
||||
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
|
||||
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
|
||||
*/
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_key,
|
||||
(png_size_t)(key_len + 1));
|
||||
if (text_len)
|
||||
png_write_chunk_data(png_ptr, (png_bytep)text, text_len);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)text, (png_size_t)text_len);
|
||||
|
||||
png_write_chunk_end(png_ptr);
|
||||
png_free(png_ptr, new_key);
|
||||
@@ -1415,32 +1442,34 @@ png_write_zTXt(png_structp png_ptr, png_charp key, png_charp text,
|
||||
if (key == NULL || (key_len = png_check_keyword(png_ptr, key, &new_key))==0)
|
||||
{
|
||||
png_warning(png_ptr, "Empty keyword in zTXt chunk");
|
||||
png_free(png_ptr, new_key);
|
||||
return;
|
||||
}
|
||||
|
||||
if (text == NULL || *text == '\0' || compression==PNG_TEXT_COMPRESSION_NONE)
|
||||
{
|
||||
png_write_tEXt(png_ptr, new_key, text, 0);
|
||||
png_write_tEXt(png_ptr, new_key, text, (png_size_t)0);
|
||||
png_free(png_ptr, new_key);
|
||||
return;
|
||||
}
|
||||
|
||||
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)
|
||||
(key_len+text_len+2));
|
||||
png_write_chunk_start(png_ptr, (png_bytep)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,
|
||||
(png_size_t)(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, 1);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)buf, (png_size_t)1);
|
||||
/* write the compressed data */
|
||||
png_write_compressed_data_out(png_ptr, &comp);
|
||||
|
||||
@@ -1514,7 +1543,8 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
|
||||
* any non-Latin-1 characters except for NEWLINE. ISO PNG will forbid them.
|
||||
* The NUL character is forbidden by PNG-1.0 through PNG-1.2 and ISO PNG.
|
||||
*/
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_key, key_len + 1);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_key,
|
||||
(png_size_t)(key_len + 1));
|
||||
|
||||
/* set the compression flag */
|
||||
if (compression == PNG_ITXT_COMPRESSION_NONE || \
|
||||
@@ -1524,17 +1554,18 @@ png_write_iTXt(png_structp png_ptr, int compression, png_charp key,
|
||||
cbuf[0] = 1;
|
||||
/* set the compression method */
|
||||
cbuf[1] = 0;
|
||||
png_write_chunk_data(png_ptr, cbuf, 2);
|
||||
png_write_chunk_data(png_ptr, cbuf, (png_size_t)2);
|
||||
|
||||
cbuf[0] = 0;
|
||||
png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf), lang_len + 1);
|
||||
png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf), lang_key_len + 1);
|
||||
png_write_chunk_data(png_ptr, (new_lang ? (png_bytep)new_lang : cbuf),
|
||||
(png_size_t)(lang_len + 1));
|
||||
png_write_chunk_data(png_ptr, (lang_key ? (png_bytep)lang_key : cbuf),
|
||||
(png_size_t)(lang_key_len + 1));
|
||||
png_write_compressed_data_out(png_ptr, &comp);
|
||||
|
||||
png_write_chunk_end(png_ptr);
|
||||
png_free(png_ptr, new_key);
|
||||
if (new_lang)
|
||||
png_free(png_ptr, new_lang);
|
||||
png_free(png_ptr, new_lang);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1557,10 +1588,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, 9);
|
||||
png_write_chunk(png_ptr, (png_bytep)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 */
|
||||
@@ -1587,7 +1617,7 @@ png_write_pCAL(png_structp png_ptr, png_charp purpose, png_int_32 X0,
|
||||
total_len = purpose_len + units_len + 10;
|
||||
|
||||
params_len = (png_uint_32p)png_malloc(png_ptr,
|
||||
(png_size_t)(nparams * sizeof(png_uint_32)));
|
||||
(png_size_t)(nparams * png_sizeof(png_uint_32)));
|
||||
|
||||
/* Find the length of each parameter, making sure we don't count the
|
||||
null terminator for the last parameter. */
|
||||
@@ -1601,13 +1631,14 @@ 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_data(png_ptr, (png_bytep)new_purpose, purpose_len);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)new_purpose,
|
||||
(png_size_t)purpose_len);
|
||||
png_save_int_32(buf, X0);
|
||||
png_save_int_32(buf + 4, X1);
|
||||
buf[8] = (png_byte)type;
|
||||
buf[9] = (png_byte)nparams;
|
||||
png_write_chunk_data(png_ptr, buf, 10);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)units, units_len);
|
||||
png_write_chunk_data(png_ptr, buf, (png_size_t)10);
|
||||
png_write_chunk_data(png_ptr, (png_bytep)units, (png_size_t)units_len);
|
||||
|
||||
png_free(png_ptr, new_purpose);
|
||||
|
||||
@@ -1631,17 +1662,17 @@ png_write_sCAL(png_structp png_ptr, int unit, double width, double height)
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_sCAL;
|
||||
#endif
|
||||
png_size_t total_len;
|
||||
char buf[64];
|
||||
png_size_t total_len;
|
||||
|
||||
png_debug(1, "in png_write_sCAL\n");
|
||||
|
||||
buf[0] = (char)unit;
|
||||
|
||||
png_sprintf(buf + 1, "%12.12e", width);
|
||||
png_snprintf(buf + 1, 63, "%12.12e", width);
|
||||
total_len = 1 + png_strlen(buf + 1) + 1;
|
||||
png_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);
|
||||
|
||||
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);
|
||||
}
|
||||
@@ -1699,7 +1730,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, 9);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_pHYs, buf, (png_size_t)9);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1731,7 +1762,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, 7);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_tIME, buf, (png_size_t)7);
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -1739,6 +1770,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 */
|
||||
|
||||
@@ -1753,23 +1785,26 @@ 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;
|
||||
|
||||
png_debug(1, "in png_write_start_row\n");
|
||||
buf_size = (PNG_ROWBYTES(
|
||||
buf_size = (png_size_t)(PNG_ROWBYTES(
|
||||
png_ptr->usr_channels*png_ptr->usr_bit_depth, png_ptr->width) + 1);
|
||||
|
||||
/* set up row buffer */
|
||||
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, buf_size);
|
||||
png_ptr->row_buf = (png_bytep)png_malloc(png_ptr,
|
||||
(png_size_t)buf_size);
|
||||
png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE;
|
||||
|
||||
#ifndef PNG_NO_WRITE_FILTER
|
||||
/* set up filtering buffer, if using this filter */
|
||||
if (png_ptr->do_filter & PNG_FILTER_SUB)
|
||||
{
|
||||
png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
|
||||
(png_ptr->rowbytes + 1));
|
||||
(png_size_t)(png_ptr->rowbytes + 1));
|
||||
png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
|
||||
}
|
||||
|
||||
@@ -1777,29 +1812,31 @@ png_write_start_row(png_structp png_ptr)
|
||||
if (png_ptr->do_filter & (PNG_FILTER_AVG | PNG_FILTER_UP | PNG_FILTER_PAETH))
|
||||
{
|
||||
/* set up previous row buffer */
|
||||
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, buf_size);
|
||||
png_ptr->prev_row = (png_bytep)png_malloc(png_ptr,
|
||||
(png_size_t)buf_size);
|
||||
png_memset(png_ptr->prev_row, 0, buf_size);
|
||||
|
||||
if (png_ptr->do_filter & PNG_FILTER_UP)
|
||||
{
|
||||
png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
|
||||
(png_ptr->rowbytes + 1));
|
||||
(png_size_t)(png_ptr->rowbytes + 1));
|
||||
png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
|
||||
}
|
||||
|
||||
if (png_ptr->do_filter & PNG_FILTER_AVG)
|
||||
{
|
||||
png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
|
||||
(png_ptr->rowbytes + 1));
|
||||
(png_size_t)(png_ptr->rowbytes + 1));
|
||||
png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
|
||||
}
|
||||
|
||||
if (png_ptr->do_filter & PNG_FILTER_PAETH)
|
||||
{
|
||||
png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
|
||||
(png_ptr->rowbytes + 1));
|
||||
(png_size_t)(png_ptr->rowbytes + 1));
|
||||
png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
|
||||
}
|
||||
#endif /* PNG_NO_WRITE_FILTER */
|
||||
}
|
||||
|
||||
#ifdef PNG_WRITE_INTERLACING_SUPPORTED
|
||||
@@ -1833,6 +1870,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 */
|
||||
|
||||
@@ -1847,6 +1885,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;
|
||||
@@ -1895,7 +1934,7 @@ png_write_finish_row(png_structp png_ptr)
|
||||
{
|
||||
if (png_ptr->prev_row != NULL)
|
||||
png_memset(png_ptr->prev_row, 0,
|
||||
(PNG_ROWBYTES(png_ptr->usr_channels*
|
||||
(png_size_t)(PNG_ROWBYTES(png_ptr->usr_channels*
|
||||
png_ptr->usr_bit_depth, png_ptr->width)) + 1);
|
||||
return;
|
||||
}
|
||||
@@ -2121,7 +2160,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;
|
||||
@@ -2134,7 +2175,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
|
||||
@@ -2709,11 +2753,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)
|
||||
@@ -2726,6 +2771,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 */
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user