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

[devel] Tidied up some inconsistent indentation.

Browse Source
This commit is contained in:
Glenn Randers-Pehrson 2010-03-03 07:06:54 -06:00
parent 65a223794a
commit 262d0ff047
2 changed files with 98 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
pngpread.c
View File

@ -30,7 +30,7 @@
void PNGAPI void PNGAPI
png_process_data(png_structp png_ptr, png_infop info_ptr, png_process_data(png_structp png_ptr, png_infop info_ptr,
png_bytep buffer, png_size_t buffer_size) png_bytep buffer, png_size_t buffer_size)
{ {
if (png_ptr == NULL || info_ptr == NULL) if (png_ptr == NULL || info_ptr == NULL)
return; return;
@ -128,7 +128,7 @@ png_push_read_sig(png_structp png_ptr, png_infop info_ptr)
} }
png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]), png_push_fill_buffer(png_ptr, &(info_ptr->signature[num_checked]),
num_to_check); num_to_check);
png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check); png_ptr->sig_bytes = (png_byte)(png_ptr->sig_bytes + num_to_check);
if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check)) if (png_sig_cmp(info_ptr->signature, num_checked, num_to_check))
@ -232,8 +232,8 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
} }
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
if (png_ptr->mode & PNG_AFTER_IDAT) if (png_ptr->mode & PNG_AFTER_IDAT)
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4))
{ {
@ -286,7 +286,7 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
png_error(png_ptr, "Missing IHDR before IDAT"); png_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) !(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
} }
} }
@ -681,32 +681,32 @@ png_push_save_buffer(png_structp png_ptr)
istop = png_ptr->save_buffer_size; istop = png_ptr->save_buffer_size;
for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer; for (i = 0, sp = png_ptr->save_buffer_ptr, dp = png_ptr->save_buffer;
i < istop; i++, sp++, dp++) i < istop; i++, sp++, dp++)
{ {
*dp = *sp; *dp = *sp;
} }
} }
} }
if (png_ptr->save_buffer_size + png_ptr->current_buffer_size > if (png_ptr->save_buffer_size + png_ptr->current_buffer_size >
png_ptr->save_buffer_max) png_ptr->save_buffer_max)
{ {
png_size_t new_max; png_size_t new_max;
png_bytep old_buffer; png_bytep old_buffer;
if (png_ptr->save_buffer_size > PNG_SIZE_MAX - if (png_ptr->save_buffer_size > PNG_SIZE_MAX -
(png_ptr->current_buffer_size + 256)) (png_ptr->current_buffer_size + 256))
{ {
png_error(png_ptr, "Potential overflow of save_buffer"); png_error(png_ptr, "Potential overflow of save_buffer");
} }
new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256; new_max = png_ptr->save_buffer_size + png_ptr->current_buffer_size + 256;
old_buffer = png_ptr->save_buffer; old_buffer = png_ptr->save_buffer;
png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr, png_ptr->save_buffer = (png_bytep)png_malloc_warn(png_ptr,
(png_size_t)new_max); (png_size_t)new_max);
if (png_ptr->save_buffer == NULL) if (png_ptr->save_buffer == NULL)
{ {
png_free(png_ptr, old_buffer); png_free(png_ptr, old_buffer);
png_error(png_ptr, "Insufficient memory for save_buffer"); png_error(png_ptr, "Insufficient memory for save_buffer");
} }
png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size); png_memcpy(png_ptr->save_buffer, old_buffer, png_ptr->save_buffer_size);
png_free(png_ptr, old_buffer); png_free(png_ptr, old_buffer);
@ -871,10 +871,10 @@ png_process_IDAT_data(png_structp png_ptr, png_bytep buffer,
#endif #endif
png_ptr->row_number == png_ptr->num_rows)) png_ptr->row_number == png_ptr->num_rows))
{ {
if (png_ptr->zstream.avail_in) if (png_ptr->zstream.avail_in)
png_warning(png_ptr, "Too much data in IDAT chunks"); png_warning(png_ptr, "Too much data in IDAT chunks");
png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED;
break; break;
} }
png_push_process_row(png_ptr); png_push_process_row(png_ptr);
png_ptr->zstream.avail_out = png_ptr->zstream.avail_out =
@ -916,7 +916,7 @@ png_push_process_row(png_structp png_ptr)
if (png_ptr->pass < 6) if (png_ptr->pass < 6)
/* old interface (pre-1.0.9): /* old interface (pre-1.0.9):
png_do_read_interlace(&(png_ptr->row_info), png_do_read_interlace(&(png_ptr->row_info),
png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations); png_ptr->row_buf + 1, png_ptr->pass, png_ptr->transformations);
*/ */
png_do_read_interlace(png_ptr); png_do_read_interlace(png_ptr);
@ -1131,7 +1131,7 @@ png_read_push_finish_row(png_structp png_ptr)
if ((png_ptr->pass == 1 && png_ptr->width < 5) || if ((png_ptr->pass == 1 && png_ptr->width < 5) ||
(png_ptr->pass == 3 && png_ptr->width < 3) || (png_ptr->pass == 3 && png_ptr->width < 3) ||
(png_ptr->pass == 5 && png_ptr->width < 2)) (png_ptr->pass == 5 && png_ptr->width < 2))
png_ptr->pass++; png_ptr->pass++;
if (png_ptr->pass > 7) if (png_ptr->pass > 7)
png_ptr->pass--; png_ptr->pass--;
@ -1160,7 +1160,7 @@ png_read_push_finish_row(png_structp png_ptr)
#ifdef PNG_READ_tEXt_SUPPORTED #ifdef PNG_READ_tEXt_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
length) length)
{ {
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
@ -1180,7 +1180,7 @@ png_push_handle_tEXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
#endif #endif
png_ptr->current_text = (png_charp)png_malloc(png_ptr, png_ptr->current_text = (png_charp)png_malloc(png_ptr,
(png_size_t)(length + 1)); (png_size_t)(length + 1));
png_ptr->current_text[length] = '\0'; png_ptr->current_text[length] = '\0';
png_ptr->current_text_ptr = png_ptr->current_text; png_ptr->current_text_ptr = png_ptr->current_text;
png_ptr->current_text_size = (png_size_t)length; png_ptr->current_text_size = (png_size_t)length;
@ -1234,7 +1234,7 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
text++; text++;
text_ptr = (png_textp)png_malloc(png_ptr, text_ptr = (png_textp)png_malloc(png_ptr,
png_sizeof(png_text)); png_sizeof(png_text));
text_ptr->compression = PNG_TEXT_COMPRESSION_NONE; text_ptr->compression = PNG_TEXT_COMPRESSION_NONE;
text_ptr->key = key; text_ptr->key = key;
#ifdef PNG_iTXt_SUPPORTED #ifdef PNG_iTXt_SUPPORTED
@ -1250,7 +1250,7 @@ png_push_read_tEXt(png_structp png_ptr, png_infop info_ptr)
png_ptr->current_text = NULL; png_ptr->current_text = NULL;
if (ret) if (ret)
png_warning(png_ptr, "Insufficient memory to store text chunk"); png_warning(png_ptr, "Insufficient memory to store text chunk");
} }
} }
#endif #endif
@ -1280,7 +1280,7 @@ png_push_handle_zTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
#endif #endif
png_ptr->current_text = (png_charp)png_malloc(png_ptr, png_ptr->current_text = (png_charp)png_malloc(png_ptr,
(png_size_t)(length + 1)); (png_size_t)(length + 1));
png_ptr->current_text[length] = '\0'; png_ptr->current_text[length] = '\0';
png_ptr->current_text_ptr = png_ptr->current_text; png_ptr->current_text_ptr = png_ptr->current_text;
png_ptr->current_text_size = (png_size_t)length; png_ptr->current_text_size = (png_size_t)length;
@ -1347,7 +1347,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
png_ptr->zstream.next_in = (png_bytep )text; png_ptr->zstream.next_in = (png_bytep )text;
png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size - png_ptr->zstream.avail_in = (uInt)(png_ptr->current_text_size -
(text - key)); (text - key));
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;
@ -1373,16 +1373,16 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
if (text == NULL) if (text == NULL)
{ {
text = (png_charp)png_malloc(png_ptr, text = (png_charp)png_malloc(png_ptr,
(png_ptr->zbuf_size (png_ptr->zbuf_size
- png_ptr->zstream.avail_out + key_size + 1)); - png_ptr->zstream.avail_out + key_size + 1));
png_memcpy(text + key_size, png_ptr->zbuf, png_memcpy(text + key_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
png_memcpy(text, key, key_size); png_memcpy(text, key, key_size);
text_size = key_size + png_ptr->zbuf_size - text_size = key_size + png_ptr->zbuf_size -
png_ptr->zstream.avail_out; png_ptr->zstream.avail_out;
*(text + text_size) = '\0'; *(text + text_size) = '\0';
} }
@ -1392,14 +1392,14 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
tmp = text; tmp = text;
text = (png_charp)png_malloc(png_ptr, text_size + text = (png_charp)png_malloc(png_ptr, text_size +
(png_ptr->zbuf_size (png_ptr->zbuf_size
- png_ptr->zstream.avail_out + 1)); - png_ptr->zstream.avail_out + 1));
png_memcpy(text, tmp, text_size); png_memcpy(text, tmp, text_size);
png_free(png_ptr, tmp); png_free(png_ptr, tmp);
png_memcpy(text + text_size, png_ptr->zbuf, png_memcpy(text + text_size, png_ptr->zbuf,
png_ptr->zbuf_size - png_ptr->zstream.avail_out); png_ptr->zbuf_size - png_ptr->zstream.avail_out);
text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out; text_size += png_ptr->zbuf_size - png_ptr->zstream.avail_out;
*(text + text_size) = '\0'; *(text + text_size) = '\0';
@ -1451,7 +1451,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
png_free(png_ptr, text_ptr); png_free(png_ptr, text_ptr);
if (ret) if (ret)
png_warning(png_ptr, "Insufficient memory to store text chunk"); png_warning(png_ptr, "Insufficient memory to store text chunk");
} }
} }
#endif #endif
@ -1459,7 +1459,7 @@ png_push_read_zTXt(png_structp png_ptr, png_infop info_ptr)
#ifdef PNG_READ_iTXt_SUPPORTED #ifdef PNG_READ_iTXt_SUPPORTED
void /* PRIVATE */ void /* PRIVATE */
png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
length) length)
{ {
if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND)) if (!(png_ptr->mode & PNG_HAVE_IHDR) || (png_ptr->mode & PNG_HAVE_IEND))
{ {
@ -1479,7 +1479,7 @@ png_push_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32
#endif #endif
png_ptr->current_text = (png_charp)png_malloc(png_ptr, png_ptr->current_text = (png_charp)png_malloc(png_ptr,
(png_size_t)(length + 1)); (png_size_t)(length + 1));
png_ptr->current_text[length] = '\0'; png_ptr->current_text[length] = '\0';
png_ptr->current_text_ptr = png_ptr->current_text; png_ptr->current_text_ptr = png_ptr->current_text;
png_ptr->current_text_size = (png_size_t)length; png_ptr->current_text_size = (png_size_t)length;
@ -1548,15 +1548,15 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
if (lang_key < key + png_ptr->current_text_size - 1) if (lang_key < key + png_ptr->current_text_size - 1)
{ {
for (; *text; text++) for (; *text; text++)
/* Empty loop */ ; /* Empty loop */ ;
} }
if (text < key + png_ptr->current_text_size) if (text < key + png_ptr->current_text_size)
text++; text++;
text_ptr = (png_textp)png_malloc(png_ptr, text_ptr = (png_textp)png_malloc(png_ptr,
png_sizeof(png_text)); png_sizeof(png_text));
text_ptr->compression = comp_flag + 2; text_ptr->compression = comp_flag + 2;
text_ptr->key = key; text_ptr->key = key;
@ -1583,7 +1583,7 @@ png_push_read_iTXt(png_structp png_ptr, png_infop info_ptr)
*/ */
void /* PRIVATE */ void /* PRIVATE */
png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32 png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
length) length)
{ {
png_uint_32 skip = 0; png_uint_32 skip = 0;
@ -1591,11 +1591,11 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
{ {
#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
PNG_HANDLE_CHUNK_ALWAYS PNG_HANDLE_CHUNK_ALWAYS
#ifdef PNG_READ_USER_CHUNKS_SUPPORTED #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
&& png_ptr->read_user_chunk_fn == NULL && png_ptr->read_user_chunk_fn == NULL
#endif #endif
) )
#endif #endif
png_chunk_error(png_ptr, "unknown critical chunk"); png_chunk_error(png_ptr, "unknown critical chunk");
@ -1608,16 +1608,16 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
#ifdef PNG_MAX_MALLOC_64K #ifdef PNG_MAX_MALLOC_64K
if (length > (png_uint_32)65535L) if (length > (png_uint_32)65535L)
{ {
png_warning(png_ptr, "unknown chunk too large to fit in memory"); png_warning(png_ptr, "unknown chunk too large to fit in memory");
skip = length - (png_uint_32)65535L; skip = length - (png_uint_32)65535L;
length = (png_uint_32)65535L; length = (png_uint_32)65535L;
} }
#endif #endif
png_memcpy((png_charp)png_ptr->unknown_chunk.name, png_memcpy((png_charp)png_ptr->unknown_chunk.name,
(png_charp)png_ptr->chunk_name, (png_charp)png_ptr->chunk_name,
png_sizeof(png_ptr->unknown_chunk.name)); png_sizeof(png_ptr->unknown_chunk.name));
png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1] png_ptr->unknown_chunk.name[png_sizeof(png_ptr->unknown_chunk.name) - 1]
= '\0'; = '\0';
png_ptr->unknown_chunk.size = (png_size_t)length; png_ptr->unknown_chunk.size = (png_size_t)length;
@ -1627,7 +1627,7 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
else else
{ {
png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr, png_ptr->unknown_chunk.data = (png_bytep)png_malloc(png_ptr,
(png_size_t)length); (png_size_t)length);
png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length); png_crc_read(png_ptr, (png_bytep)png_ptr->unknown_chunk.data, length);
} }
@ -1637,7 +1637,7 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
/* Callback to user unknown chunk handler */ /* Callback to user unknown chunk handler */
int ret; int ret;
ret = (*(png_ptr->read_user_chunk_fn)) ret = (*(png_ptr->read_user_chunk_fn))
(png_ptr, &png_ptr->unknown_chunk); (png_ptr, &png_ptr->unknown_chunk);
if (ret < 0) if (ret < 0)
png_chunk_error(png_ptr, "error in user chunk"); png_chunk_error(png_ptr, "error in user chunk");
@ -1646,16 +1646,16 @@ png_push_handle_unknown(png_structp png_ptr, png_infop info_ptr, png_uint_32
{ {
if (!(png_ptr->chunk_name[0] & 0x20)) if (!(png_ptr->chunk_name[0] & 0x20))
if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) != if (png_handle_as_unknown(png_ptr, png_ptr->chunk_name) !=
PNG_HANDLE_CHUNK_ALWAYS) PNG_HANDLE_CHUNK_ALWAYS)
png_chunk_error(png_ptr, "unknown critical chunk"); png_chunk_error(png_ptr, "unknown critical 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);
} }
} }
else else
#endif #endif
png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1); png_set_unknown_chunks(png_ptr, info_ptr, &png_ptr->unknown_chunk, 1);
png_free(png_ptr, png_ptr->unknown_chunk.data); png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr->unknown_chunk.data = NULL; png_ptr->unknown_chunk.data = NULL;
} }
@ -1690,7 +1690,7 @@ png_push_have_row(png_structp png_ptr, png_bytep row)
void PNGAPI void PNGAPI
png_progressive_combine_row (png_structp png_ptr, png_progressive_combine_row (png_structp png_ptr,
png_bytep old_row, png_bytep new_row) png_bytep old_row, png_bytep new_row)
{ {
PNG_CONST int FARDATA png_pass_dsp_mask[7] = PNG_CONST int FARDATA png_pass_dsp_mask[7] =
{0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff}; {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
@ -1704,8 +1704,8 @@ png_progressive_combine_row (png_structp png_ptr,
void PNGAPI void PNGAPI
png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr, png_set_progressive_read_fn(png_structp png_ptr, png_voidp progressive_ptr,
png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn,
png_progressive_end_ptr end_fn) png_progressive_end_ptr end_fn)
{ {
if (png_ptr == NULL) if (png_ptr == NULL)
return; return;

92
pngread.c
View File

@ -24,7 +24,7 @@
/* Create a PNG structure for reading, and allocate any memory needed. */ /* Create a PNG structure for reading, and allocate any memory needed. */
png_structp PNGAPI png_structp PNGAPI
png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr, png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn) png_error_ptr error_fn, png_error_ptr warn_fn)
{ {
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
@ -37,8 +37,8 @@ png_create_read_struct(png_const_charp user_png_ver, png_voidp error_ptr,
*/ */
png_structp PNGAPI png_structp PNGAPI
png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr, png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
png_malloc_ptr malloc_fn, png_free_ptr free_fn) png_malloc_ptr malloc_fn, png_free_ptr free_fn)
{ {
#endif /* PNG_USER_MEM_SUPPORTED */ #endif /* PNG_USER_MEM_SUPPORTED */
@ -112,7 +112,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
} while (png_libpng_ver[i++]); } while (png_libpng_ver[i++]);
} }
else else
png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH; png_ptr->flags |= PNG_FLAG_LIBRARY_MISMATCH;
if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH) if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
@ -130,21 +130,21 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
char msg[80]; char msg[80];
if (user_png_ver) if (user_png_ver)
{ {
png_snprintf(msg, 80, png_snprintf(msg, 80,
"Application was compiled with png.h from libpng-%.20s", "Application was compiled with png.h from libpng-%.20s",
user_png_ver); user_png_ver);
png_warning(png_ptr, msg); png_warning(png_ptr, msg);
} }
png_snprintf(msg, 80, png_snprintf(msg, 80,
"Application is running with png.c from libpng-%.20s", "Application is running with png.c from libpng-%.20s",
png_libpng_ver); png_libpng_ver);
png_warning(png_ptr, msg); png_warning(png_ptr, msg);
#endif #endif
#ifdef PNG_ERROR_NUMBERS_SUPPORTED #ifdef PNG_ERROR_NUMBERS_SUPPORTED
png_ptr->flags = 0; png_ptr->flags = 0;
#endif #endif
png_warning(png_ptr, png_warning(png_ptr,
"Incompatible libpng version in application and library"); "Incompatible libpng version in application and library");
png_cleanup_needed = 1; png_cleanup_needed = 1;
} }
@ -155,9 +155,9 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
/* Initialize zbuf - compression buffer */ /* Initialize zbuf - compression buffer */
png_ptr->zbuf_size = PNG_ZBUF_SIZE; png_ptr->zbuf_size = PNG_ZBUF_SIZE;
png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr, png_ptr->zbuf = (png_bytep)png_malloc_warn(png_ptr,
png_ptr->zbuf_size); png_ptr->zbuf_size);
if (png_ptr->zbuf == NULL) if (png_ptr->zbuf == NULL)
png_cleanup_needed = 1; png_cleanup_needed = 1;
} }
png_ptr->zstream.zalloc = png_zalloc; png_ptr->zstream.zalloc = png_zalloc;
png_ptr->zstream.zfree = png_zfree; png_ptr->zstream.zfree = png_zfree;
@ -185,7 +185,7 @@ png_create_read_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
png_ptr->zbuf = NULL; png_ptr->zbuf = NULL;
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
png_destroy_struct_2((png_voidp)png_ptr, png_destroy_struct_2((png_voidp)png_ptr,
(png_free_ptr)free_fn, (png_voidp)mem_ptr); (png_free_ptr)free_fn, (png_voidp)mem_ptr);
#else #else
png_destroy_struct((png_voidp)png_ptr); png_destroy_struct((png_voidp)png_ptr);
#endif #endif
@ -308,8 +308,8 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
* matching the chunk name rather than a linear search. * matching the chunk name rather than a linear search.
*/ */
if (!png_memcmp(chunk_name, png_IDAT, 4)) if (!png_memcmp(chunk_name, png_IDAT, 4))
if (png_ptr->mode & PNG_AFTER_IDAT) if (png_ptr->mode & PNG_AFTER_IDAT)
png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT;
if (!png_memcmp(chunk_name, png_IHDR, 4)) if (!png_memcmp(chunk_name, png_IHDR, 4))
png_handle_IHDR(png_ptr, info_ptr, length); png_handle_IHDR(png_ptr, info_ptr, length);
@ -328,7 +328,7 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before IDAT"); png_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) !(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
break; break;
} }
@ -341,7 +341,7 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
if (!(png_ptr->mode & PNG_HAVE_IHDR)) if (!(png_ptr->mode & PNG_HAVE_IHDR))
png_error(png_ptr, "Missing IHDR before IDAT"); png_error(png_ptr, "Missing IHDR before IDAT");
else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE && else if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE &&
!(png_ptr->mode & PNG_HAVE_PLTE)) !(png_ptr->mode & PNG_HAVE_PLTE))
png_error(png_ptr, "Missing PLTE before IDAT"); png_error(png_ptr, "Missing PLTE before IDAT");
png_ptr->idat_size = length; png_ptr->idat_size = length;
@ -434,7 +434,8 @@ png_read_update_info(png_structp png_ptr, png_infop info_ptr)
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
else else
png_warning(png_ptr, png_warning(png_ptr,
"Ignoring extra png_read_update_info() call; row buffer not reallocated"); "Ignoring extra png_read_update_info() call;"
" row buffer not reallocated");
png_read_transform_info(png_ptr, info_ptr); png_read_transform_info(png_ptr, info_ptr);
} }
@ -463,7 +464,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
{ {
PNG_IDAT; PNG_IDAT;
PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, PNG_CONST int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
0xff}; 0xff};
PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; PNG_CONST int png_pass_mask[7] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
int ret; int ret;
@ -471,7 +472,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
return; return;
png_debug2(1, "in png_read_row (row %lu, pass %d)", png_debug2(1, "in png_read_row (row %lu, pass %d)",
(unsigned long) png_ptr->row_number, png_ptr->pass); (unsigned long) png_ptr->row_number, png_ptr->pass);
if (!(png_ptr->flags & PNG_FLAG_ROW_INIT)) if (!(png_ptr->flags & PNG_FLAG_ROW_INIT))
png_read_start_row(png_ptr); png_read_start_row(png_ptr);
@ -610,7 +611,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
if (png_ptr->zbuf_size > png_ptr->idat_size) if (png_ptr->zbuf_size > png_ptr->idat_size)
png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size; png_ptr->zstream.avail_in = (uInt)png_ptr->idat_size;
png_crc_read(png_ptr, png_ptr->zbuf, png_crc_read(png_ptr, png_ptr->zbuf,
(png_size_t)png_ptr->zstream.avail_in); (png_size_t)png_ptr->zstream.avail_in);
png_ptr->idat_size -= png_ptr->zstream.avail_in; png_ptr->idat_size -= png_ptr->zstream.avail_in;
} }
ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH); ret = inflate(&png_ptr->zstream, Z_PARTIAL_FLUSH);
@ -625,7 +626,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
} }
if (ret != Z_OK) if (ret != Z_OK)
png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg : png_error(png_ptr, png_ptr->zstream.msg ? png_ptr->zstream.msg :
"Decompression error"); "Decompression error");
} while (png_ptr->zstream.avail_out); } while (png_ptr->zstream.avail_out);
@ -639,14 +640,14 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
if (png_ptr->row_buf[0]) if (png_ptr->row_buf[0])
png_read_filter_row(png_ptr, &(png_ptr->row_info), png_read_filter_row(png_ptr, &(png_ptr->row_info),
png_ptr->row_buf + 1, png_ptr->prev_row + 1, png_ptr->row_buf + 1, png_ptr->prev_row + 1,
(int)(png_ptr->row_buf[0])); (int)(png_ptr->row_buf[0]));
png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1); png_memcpy(png_ptr->prev_row, png_ptr->row_buf, png_ptr->rowbytes + 1);
#ifdef PNG_MNG_FEATURES_SUPPORTED #ifdef PNG_MNG_FEATURES_SUPPORTED
if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) && if ((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING)) (png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
{ {
/* Intrapixel differencing */ /* Intrapixel differencing */
png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1); png_do_read_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
@ -670,11 +671,9 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
png_do_read_interlace(png_ptr); png_do_read_interlace(png_ptr);
if (dsp_row != NULL) if (dsp_row != NULL)
png_combine_row(png_ptr, dsp_row, png_combine_row(png_ptr, dsp_row, png_pass_dsp_mask[png_ptr->pass]);
png_pass_dsp_mask[png_ptr->pass]);
if (row != NULL) if (row != NULL)
png_combine_row(png_ptr, row, png_combine_row(png_ptr, row, png_pass_mask[png_ptr->pass]);
png_pass_mask[png_ptr->pass]);
} }
else else
#endif #endif
@ -718,7 +717,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
void PNGAPI void PNGAPI
png_read_rows(png_structp png_ptr, png_bytepp row, png_read_rows(png_structp png_ptr, png_bytepp row,
png_bytepp display_row, png_uint_32 num_rows) png_bytepp display_row, png_uint_32 num_rows)
{ {
png_uint_32 i; png_uint_32 i;
png_bytepp rp; png_bytepp rp;
@ -785,7 +784,7 @@ png_read_image(png_structp png_ptr, png_bytepp image)
#else #else
if (png_ptr->interlaced) if (png_ptr->interlaced)
png_error(png_ptr, png_error(png_ptr,
"Cannot read interlaced image -- interlace handler disabled"); "Cannot read interlaced image -- interlace handler disabled");
pass = 1; pass = 1;
#endif #endif
@ -984,7 +983,7 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
/* Free all memory used by the read */ /* Free all memory used by the read */
void PNGAPI void PNGAPI
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
png_infopp end_info_ptr_ptr) png_infopp end_info_ptr_ptr)
{ {
png_structp png_ptr = NULL; png_structp png_ptr = NULL;
png_infop info_ptr = NULL, end_info_ptr = NULL; png_infop info_ptr = NULL, end_info_ptr = NULL;
@ -1035,7 +1034,7 @@ png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
#endif #endif
#ifdef PNG_USER_MEM_SUPPORTED #ifdef PNG_USER_MEM_SUPPORTED
png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn, png_destroy_struct_2((png_voidp)end_info_ptr, (png_free_ptr)free_fn,
(png_voidp)mem_ptr); (png_voidp)mem_ptr);
#else #else
png_destroy_struct((png_voidp)end_info_ptr); png_destroy_struct((png_voidp)end_info_ptr);
#endif #endif
@ -1284,40 +1283,35 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
#endif #endif
#ifdef PNG_READ_BGR_SUPPORTED #ifdef PNG_READ_BGR_SUPPORTED
/* Flip the RGB pixels to BGR (or RGBA to BGRA) /* Flip the RGB pixels to BGR (or RGBA to BGRA) */
*/
if (transforms & PNG_TRANSFORM_BGR) if (transforms & PNG_TRANSFORM_BGR)
png_set_bgr(png_ptr); png_set_bgr(png_ptr);
#endif #endif
#ifdef PNG_READ_SWAP_ALPHA_SUPPORTED #ifdef PNG_READ_SWAP_ALPHA_SUPPORTED
/* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) /* Swap the RGBA or GA data to ARGB or AG (or BGRA to ABGR) */
*/
if (transforms & PNG_TRANSFORM_SWAP_ALPHA) if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
png_set_swap_alpha(png_ptr); png_set_swap_alpha(png_ptr);
#endif #endif
#ifdef PNG_READ_SWAP_SUPPORTED #ifdef PNG_READ_SWAP_SUPPORTED
/* Swap bytes of 16 bit files to least significant byte first /* Swap bytes of 16 bit files to least significant byte first */
*/
if (transforms & PNG_TRANSFORM_SWAP_ENDIAN) if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
png_set_swap(png_ptr); png_set_swap(png_ptr);
#endif #endif
/* Added at libpng-1.2.41 */ /* Added at libpng-1.2.41 */
#ifdef PNG_READ_INVERT_ALPHA_SUPPORTED #ifdef PNG_READ_INVERT_ALPHA_SUPPORTED
/* Invert the alpha channel from opacity to transparency /* Invert the alpha channel from opacity to transparency */
*/
if (transforms & PNG_TRANSFORM_INVERT_ALPHA) if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
png_set_invert_alpha(png_ptr); png_set_invert_alpha(png_ptr);
#endif #endif
/* Added at libpng-1.2.41 */ /* Added at libpng-1.2.41 */
#ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
/* Expand grayscale image to RGB /* Expand grayscale image to RGB */
*/
if (transforms & PNG_TRANSFORM_GRAY_TO_RGB) if (transforms & PNG_TRANSFORM_GRAY_TO_RGB)
png_set_gray_to_rgb(png_ptr); png_set_gray_to_rgb(png_ptr);
#endif #endif
/* We don't handle adding filler bytes */ /* We don't handle adding filler bytes */
@ -1333,10 +1327,10 @@ png_read_png(png_structp png_ptr, png_infop info_ptr,
png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0); png_free_data(png_ptr, info_ptr, PNG_FREE_ROWS, 0);
if (info_ptr->row_pointers == NULL) if (info_ptr->row_pointers == NULL)
{ {
png_uint_32 iptr; png_uint_32 iptr;
info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr, info_ptr->row_pointers = (png_bytepp)png_malloc(png_ptr,
info_ptr->height * png_sizeof(png_bytep)); info_ptr->height * png_sizeof(png_bytep));
for (iptr=0; iptr<info_ptr->height; iptr++) for (iptr=0; iptr<info_ptr->height; iptr++)
info_ptr->row_pointers[iptr] = NULL; info_ptr->row_pointers[iptr] = NULL;