mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-08 19:04:45 +00:00
removing CRCs from the acTl chunk and making all the chunks not-safe-for-copy. r=asmith15@learn.senecac.on.ca
This commit is contained in:
pavlov%pavlov.net
parent
5c851310ae
commit
042fe230a9
@ -51,9 +51,9 @@ PNG_tEXt;
|
||||
PNG_tIME;
|
||||
PNG_tRNS;
|
||||
PNG_zTXt;
|
||||
PNG_acTl;
|
||||
PNG_fcTl;
|
||||
PNG_fdAt;
|
||||
PNG_acTL;
|
||||
PNG_fcTL;
|
||||
PNG_fdAT;
|
||||
|
||||
#ifdef PNG_READ_SUPPORTED
|
||||
/* arrays to facilitate easy interlacing - use pass (0 - 6) as index */
|
||||
|
||||
@ -1013,8 +1013,8 @@ typedef png_info FAR * FAR * png_infopp;
|
||||
#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */
|
||||
#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */
|
||||
#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */
|
||||
#define PNG_INFO_acTl 0x10000L
|
||||
#define PNG_INFO_fcTl 0x20000L
|
||||
#define PNG_INFO_acTL 0x10000L
|
||||
#define PNG_INFO_fcTL 0x20000L
|
||||
|
||||
/* This is used for the transformation routines, as some of them
|
||||
* change these values for the row. It also should enable using
|
||||
@ -1387,9 +1387,7 @@ struct png_struct_def
|
||||
|
||||
#if defined(PNG_APNG_SUPPORTED)
|
||||
png_uint_32 apng_flags;
|
||||
png_uint_32 IHDR_crc; /* read or written */
|
||||
png_uint_32 PLTE_crc; /* read or written */
|
||||
png_uint_32 next_seq_num; /* next fcTl/fdAt chunk sequence number */
|
||||
png_uint_32 next_seq_num; /* next fcTL/fdAT chunk sequence number */
|
||||
png_uint_32 first_frame_width;
|
||||
png_uint_32 first_frame_height;
|
||||
#endif
|
||||
@ -1413,7 +1411,7 @@ struct png_struct_def
|
||||
/* For png_struct.apng_flags: */
|
||||
#define PNG_FIRST_FRAME_HIDDEN 0x0001
|
||||
|
||||
/* dispose_op flags from render_op inside fcTl */
|
||||
/* dispose_op flags from render_op inside fcTL */
|
||||
#define PNG_RENDER_OP_DISPOSE_MASK 0x07
|
||||
#define PNG_RENDER_OP_DISPOSE_NONE 0x01
|
||||
#define PNG_RENDER_OP_DISPOSE_BACKGROUND 0x02
|
||||
@ -2431,24 +2429,24 @@ extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr,
|
||||
#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */
|
||||
|
||||
#if defined(PNG_APNG_SUPPORTED)
|
||||
extern PNG_EXPORT(png_uint_32,png_get_acTl) PNGARG((png_structp png_ptr,
|
||||
extern PNG_EXPORT(png_uint_32,png_get_acTL) PNGARG((png_structp png_ptr,
|
||||
png_infop info_ptr, png_uint_32 *num_frames, png_uint_32 *num_iterations));
|
||||
extern PNG_EXPORT(png_uint_32,png_set_acTl) PNGARG((png_structp png_ptr,
|
||||
extern PNG_EXPORT(png_uint_32,png_set_acTL) PNGARG((png_structp png_ptr,
|
||||
png_infop info_ptr, png_uint_32 num_frames, png_uint_32 num_iterations));
|
||||
extern PNG_EXPORT(png_uint_32,png_get_num_frames) PNGARG((png_structp png_ptr,
|
||||
png_infop info_ptr));
|
||||
extern PNG_EXPORT(png_uint_32,png_get_num_iterations)
|
||||
PNGARG((png_structp png_ptr, png_infop info_ptr));
|
||||
|
||||
extern PNG_EXPORT(png_uint_32,png_get_next_frame_fcTl)
|
||||
extern PNG_EXPORT(png_uint_32,png_get_next_frame_fcTL)
|
||||
PNGARG((png_structp png_ptr, png_infop info_ptr, png_uint_32 *width,
|
||||
png_uint_32 *height, png_uint_32 *x_offset, png_uint_32 *y_offset,
|
||||
png_uint_16 *delay_num, png_uint_16 *delay_den, png_byte *render_op));
|
||||
extern PNG_EXPORT(png_uint_32,png_set_next_frame_fcTl)
|
||||
extern PNG_EXPORT(png_uint_32,png_set_next_frame_fcTL)
|
||||
PNGARG((png_structp png_ptr, png_infop info_ptr, png_uint_32 width,
|
||||
png_uint_32 height, png_uint_32 x_offset, png_uint_32 y_offset,
|
||||
png_uint_16 delay_num, png_uint_16 delay_den, png_byte render_op));
|
||||
extern PNG_EXPORT(void,png_ensure_fcTl_is_valid)
|
||||
extern PNG_EXPORT(void,png_ensure_fcTL_is_valid)
|
||||
PNGARG((png_structp png_ptr,
|
||||
png_uint_32 width, png_uint_32 height,
|
||||
png_uint_32 x_offset, png_uint_32 y_offset,
|
||||
@ -2780,8 +2778,8 @@ extern PNG_EXPORT(void,png_save_uint_16)
|
||||
#define PNG_BACKGROUND_IS_GRAY 0x800
|
||||
#define PNG_HAVE_PNG_SIGNATURE 0x1000
|
||||
#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */
|
||||
#define PNG_HAVE_acTl 0x4000
|
||||
#define PNG_HAVE_fcTl 0x8000L
|
||||
#define PNG_HAVE_acTL 0x4000
|
||||
#define PNG_HAVE_fcTL 0x8000L
|
||||
|
||||
/* flags for the transformations the PNG library does on the image data */
|
||||
#define PNG_BGR 0x0001
|
||||
@ -2925,9 +2923,9 @@ extern PNG_EXPORT(void,png_save_uint_16)
|
||||
#define PNG_tIME const png_byte png_tIME[5] = {116, 73, 77, 69, '\0'}
|
||||
#define PNG_tRNS const png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'}
|
||||
#define PNG_zTXt const png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'}
|
||||
#define PNG_acTl const png_byte png_acTl[5] = { 97, 99, 84, 108, '\0'}
|
||||
#define PNG_fcTl const png_byte png_fcTl[5] = {102, 99, 84, 108, '\0'}
|
||||
#define PNG_fdAt const png_byte png_fdAt[5] = {102, 100, 65, 116, '\0'}
|
||||
#define PNG_acTL const png_byte png_acTL[5] = { 97, 99, 84, 76, '\0'}
|
||||
#define PNG_fcTL const png_byte png_fcTL[5] = {102, 99, 84, 76, '\0'}
|
||||
#define PNG_fdAT const png_byte png_fdAT[5] = {102, 100, 65, 84, '\0'}
|
||||
|
||||
#ifdef PNG_USE_GLOBAL_ARRAYS
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5];
|
||||
@ -2951,9 +2949,9 @@ PNG_EXPORT_VAR (const png_byte FARDATA) png_tEXt[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_tIME[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_tRNS[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_zTXt[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_acTl[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_fcTl[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_fdAt[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_acTL[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_fcTL[5];
|
||||
PNG_EXPORT_VAR (const png_byte FARDATA) png_fdAT[5];
|
||||
#endif /* PNG_USE_GLOBAL_ARRAYS */
|
||||
|
||||
#if defined(PNG_1_0_X) || defined (PNG_1_2_X)
|
||||
@ -3229,10 +3227,10 @@ PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr,
|
||||
#endif
|
||||
|
||||
#if defined(PNG_WRITE_APNG_SUPPORTED)
|
||||
PNG_EXTERN void png_write_acTl PNGARG((png_structp png_ptr,
|
||||
PNG_EXTERN void png_write_acTL PNGARG((png_structp png_ptr,
|
||||
png_uint_32 num_frames, png_uint_32 num_iterations));
|
||||
|
||||
PNG_EXTERN void png_write_fcTl PNGARG((png_structp png_ptr,
|
||||
PNG_EXTERN void png_write_fcTL PNGARG((png_structp png_ptr,
|
||||
png_uint_32 width, png_uint_32 height,
|
||||
png_uint_32 x_offset, png_uint_32 y_offset,
|
||||
png_uint_16 delay_num, png_uint_16 delay_den, png_byte render_op));
|
||||
@ -3519,11 +3517,11 @@ PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr,
|
||||
#endif
|
||||
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
PNG_EXTERN void png_handle_acTl PNGARG((png_structp png_ptr, png_infop info_ptr,
|
||||
PNG_EXTERN void png_handle_acTL PNGARG((png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 length));
|
||||
PNG_EXTERN void png_handle_fcTl PNGARG((png_structp png_ptr, png_infop info_ptr,
|
||||
PNG_EXTERN void png_handle_fcTL PNGARG((png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 length));
|
||||
PNG_EXTERN void png_handle_fdAt PNGARG((png_structp png_ptr, png_infop info_ptr,
|
||||
PNG_EXTERN void png_handle_fdAT PNGARG((png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 length));
|
||||
PNG_EXTERN void png_ensure_sequence_number PNGARG((png_structp png_ptr,
|
||||
png_uint_32 length));
|
||||
|
||||
@ -796,13 +796,13 @@ png_get_tRNS(png_structp png_ptr, png_infop info_ptr,
|
||||
|
||||
#if defined(PNG_APNG_SUPPORTED)
|
||||
png_uint_32 PNGAPI
|
||||
png_get_acTl(png_structp png_ptr, png_infop info_ptr,
|
||||
png_get_acTL(png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 *num_frames, png_uint_32 *num_iterations)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "acTl");
|
||||
png_debug1(1, "in %s retrieval function\n", "acTL");
|
||||
|
||||
if (png_ptr != NULL && info_ptr != NULL &&
|
||||
(info_ptr->valid & PNG_INFO_acTl) &&
|
||||
(info_ptr->valid & PNG_INFO_acTL) &&
|
||||
num_frames != NULL && num_iterations != NULL)
|
||||
{
|
||||
*num_frames = info_ptr->num_frames;
|
||||
@ -834,16 +834,16 @@ png_get_num_iterations(png_structp png_ptr, png_infop info_ptr)
|
||||
}
|
||||
|
||||
png_uint_32 PNGAPI
|
||||
png_get_next_frame_fcTl(png_structp png_ptr, png_infop info_ptr,
|
||||
png_get_next_frame_fcTL(png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 *width, png_uint_32 *height,
|
||||
png_uint_32 *x_offset, png_uint_32 *y_offset,
|
||||
png_uint_16 *delay_num, png_uint_16 *delay_den,
|
||||
png_byte *render_op)
|
||||
{
|
||||
png_debug1(1, "in %s retrieval function\n", "fcTl");
|
||||
png_debug1(1, "in %s retrieval function\n", "fcTL");
|
||||
|
||||
if (png_ptr != NULL && info_ptr != NULL &&
|
||||
(info_ptr->valid & PNG_INFO_fcTl) &&
|
||||
(info_ptr->valid & PNG_INFO_fcTL) &&
|
||||
width != NULL && height != NULL &&
|
||||
x_offset != NULL && x_offset != NULL &&
|
||||
delay_num != NULL && delay_den != NULL && render_op != NULL)
|
||||
@ -937,8 +937,8 @@ png_first_frame_is_hidden(png_structp png_ptr, png_infop info_ptr)
|
||||
png_debug(1, "in png_first_frame_is_hidden()\n");
|
||||
|
||||
if (png_ptr != NULL && info_ptr != NULL &&
|
||||
info_ptr->valid & PNG_INFO_acTl &&
|
||||
!(info_ptr->valid & PNG_INFO_fcTl))
|
||||
info_ptr->valid & PNG_INFO_acTL &&
|
||||
!(info_ptr->valid & PNG_INFO_fcTL))
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
|
||||
@ -191,9 +191,9 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
|
||||
PNG_zTXt;
|
||||
#endif
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
PNG_acTl;
|
||||
PNG_fcTl;
|
||||
PNG_fdAt;
|
||||
PNG_acTL;
|
||||
PNG_fcTL;
|
||||
PNG_fdAT;
|
||||
#endif
|
||||
#endif /* PNG_USE_LOCAL_ARRAYS */
|
||||
/* First we make sure we have enough data for the 4 byte chunk name
|
||||
@ -226,7 +226,7 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
|
||||
if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4))
|
||||
{
|
||||
/* discard trailing IDATs for the first frame */
|
||||
if (png_ptr->mode & PNG_HAVE_fcTl || png_ptr->num_frames_read > 1)
|
||||
if (png_ptr->mode & PNG_HAVE_fcTL || png_ptr->num_frames_read > 1)
|
||||
png_error(png_ptr, "out of place IDAT");
|
||||
|
||||
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
|
||||
@ -238,7 +238,7 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
|
||||
png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER;
|
||||
return;
|
||||
}
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAt, 4))
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAT, 4))
|
||||
{
|
||||
if (png_ptr->buffer_size < 4)
|
||||
{
|
||||
@ -247,11 +247,11 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
|
||||
}
|
||||
png_ensure_sequence_number(png_ptr, 4);
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_fcTl))
|
||||
if (!(png_ptr->mode & PNG_HAVE_fcTL))
|
||||
{
|
||||
/* discard trailing fdAts for frames other than the first */
|
||||
/* discard trailing fdATs for frames other than the first */
|
||||
if (png_ptr->num_frames_read < 2)
|
||||
png_error(png_ptr, "out of place fdAt");
|
||||
png_error(png_ptr, "out of place fdAT");
|
||||
|
||||
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
|
||||
{
|
||||
@ -272,7 +272,7 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if(!png_memcmp(png_ptr->chunk_name, png_fcTl, 4))
|
||||
else if(!png_memcmp(png_ptr->chunk_name, png_fcTL, 4))
|
||||
{
|
||||
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
|
||||
{
|
||||
@ -281,12 +281,12 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
|
||||
}
|
||||
|
||||
png_read_reset(png_ptr);
|
||||
png_ptr->mode &= ~PNG_HAVE_fcTl;
|
||||
png_ptr->mode &= ~PNG_HAVE_fcTL;
|
||||
|
||||
png_handle_fcTl(png_ptr, info_ptr, png_ptr->push_length);
|
||||
png_handle_fcTL(png_ptr, info_ptr, png_ptr->push_length);
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_fcTl))
|
||||
png_error(png_ptr, "missing required fcTl chunk");
|
||||
if (!(png_ptr->mode & PNG_HAVE_fcTL))
|
||||
png_error(png_ptr, "missing required fcTL chunk");
|
||||
|
||||
png_read_reinit(png_ptr, info_ptr);
|
||||
png_progressive_read_reset(png_ptr);
|
||||
@ -591,32 +591,32 @@ png_push_read_chunk(png_structp png_ptr, png_infop info_ptr)
|
||||
}
|
||||
#endif
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_acTl, 4))
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_acTL, 4))
|
||||
{
|
||||
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
|
||||
{
|
||||
png_push_save_buffer(png_ptr);
|
||||
return;
|
||||
}
|
||||
png_handle_acTl(png_ptr, info_ptr, png_ptr->push_length);
|
||||
png_handle_acTL(png_ptr, info_ptr, png_ptr->push_length);
|
||||
}
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTl, 4))
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTL, 4))
|
||||
{
|
||||
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
|
||||
{
|
||||
png_push_save_buffer(png_ptr);
|
||||
return;
|
||||
}
|
||||
png_handle_fcTl(png_ptr, info_ptr, png_ptr->push_length);
|
||||
png_handle_fcTL(png_ptr, info_ptr, png_ptr->push_length);
|
||||
}
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAt, 4))
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAT, 4))
|
||||
{
|
||||
if (png_ptr->push_length + 4 > png_ptr->buffer_size)
|
||||
{
|
||||
png_push_save_buffer(png_ptr);
|
||||
return;
|
||||
}
|
||||
png_handle_fdAt(png_ptr, info_ptr, png_ptr->push_length);
|
||||
png_handle_fdAT(png_ptr, info_ptr, png_ptr->push_length);
|
||||
}
|
||||
#endif /* PNG_READ_APNG_SUPPORTED */
|
||||
else
|
||||
@ -790,7 +790,7 @@ png_push_read_IDAT(png_structp png_ptr)
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_IDAT;
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
PNG_fdAt;
|
||||
PNG_fdAT;
|
||||
PNG_IEND;
|
||||
#endif
|
||||
#endif
|
||||
@ -811,7 +811,7 @@ png_push_read_IDAT(png_structp png_ptr)
|
||||
png_ptr->mode |= PNG_HAVE_CHUNK_HEADER;
|
||||
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_fdAt, 4)
|
||||
if (png_memcmp(png_ptr->chunk_name, (png_bytep)png_fdAT, 4)
|
||||
&& png_ptr->num_frames_read > 0)
|
||||
{
|
||||
if (png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)
|
||||
|
||||
@ -398,9 +398,9 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
|
||||
PNG_zTXt;
|
||||
#endif
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
PNG_acTl;
|
||||
PNG_fcTl;
|
||||
PNG_fdAt;
|
||||
PNG_acTL;
|
||||
PNG_fcTL;
|
||||
PNG_fdAT;
|
||||
#endif
|
||||
#endif /* PNG_USE_LOCAL_ARRAYS */
|
||||
png_byte chunk_length[4];
|
||||
@ -528,12 +528,12 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
|
||||
png_handle_iTXt(png_ptr, info_ptr, length);
|
||||
#endif
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_acTl, 4))
|
||||
png_handle_acTl(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTl, 4))
|
||||
png_handle_fcTl(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAt, 4))
|
||||
png_handle_fdAt(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_acTL, 4))
|
||||
png_handle_acTL(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTL, 4))
|
||||
png_handle_fcTL(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAT, 4))
|
||||
png_handle_fdAT(png_ptr, info_ptr, length);
|
||||
#endif
|
||||
else
|
||||
png_handle_unknown(png_ptr, info_ptr, length);
|
||||
@ -545,30 +545,30 @@ png_read_info(png_structp png_ptr, png_infop info_ptr)
|
||||
void PNGAPI
|
||||
png_read_frame_head(png_structp png_ptr, png_infop info_ptr)
|
||||
{
|
||||
png_byte have_chunk_after_DAT; /* after IDAT or after fdAt */
|
||||
png_byte have_chunk_after_DAT; /* after IDAT or after fdAT */
|
||||
|
||||
png_debug(0, "Reading frame head\n");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_acTl))
|
||||
if (!(png_ptr->mode & PNG_HAVE_acTL))
|
||||
png_error(png_ptr, "attempt to png_read_frame_head() but "
|
||||
"no acTl present");
|
||||
"no acTL present");
|
||||
|
||||
/* do nothing for the main IDAT */
|
||||
if (png_ptr->num_frames_read == 0)
|
||||
return;
|
||||
|
||||
png_crc_finish(png_ptr, 0); /* CRC from last IDAT or fdAt chunk */
|
||||
png_crc_finish(png_ptr, 0); /* CRC from last IDAT or fdAT chunk */
|
||||
|
||||
png_read_reset(png_ptr);
|
||||
png_ptr->mode &= ~PNG_HAVE_fcTl;
|
||||
png_ptr->mode &= ~PNG_HAVE_fcTL;
|
||||
|
||||
have_chunk_after_DAT = 0;
|
||||
for (;;)
|
||||
{
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_IDAT;
|
||||
PNG_fdAt;
|
||||
PNG_fcTl;
|
||||
PNG_fdAT;
|
||||
PNG_fcTL;
|
||||
#endif
|
||||
png_byte chunk_length[4];
|
||||
png_uint_32 length;
|
||||
@ -586,19 +586,19 @@ png_read_frame_head(png_structp png_ptr, png_infop info_ptr)
|
||||
png_error(png_ptr, "png_read_frame_head(): out of place IDAT");
|
||||
png_crc_finish(png_ptr, length);
|
||||
}
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTl, 4))
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTL, 4))
|
||||
{
|
||||
png_handle_fcTl(png_ptr, info_ptr, length);
|
||||
png_handle_fcTL(png_ptr, info_ptr, length);
|
||||
have_chunk_after_DAT = 1;
|
||||
}
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAt, 4))
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAT, 4))
|
||||
{
|
||||
png_ensure_sequence_number(png_ptr, length);
|
||||
|
||||
/* discard trailing fdAts for frames other than the first */
|
||||
/* discard trailing fdATs for frames other than the first */
|
||||
if (!have_chunk_after_DAT && png_ptr->num_frames_read > 1)
|
||||
png_crc_finish(png_ptr, length - 4);
|
||||
else if(png_ptr->mode & PNG_HAVE_fcTl)
|
||||
else if(png_ptr->mode & PNG_HAVE_fcTL)
|
||||
{
|
||||
png_ptr->idat_size = length - 4;
|
||||
png_ptr->mode |= PNG_HAVE_IDAT;
|
||||
@ -606,7 +606,7 @@ png_read_frame_head(png_structp png_ptr, png_infop info_ptr)
|
||||
break;
|
||||
}
|
||||
else
|
||||
png_error(png_ptr, "png_read_frame_head(): out of place fdAt");
|
||||
png_error(png_ptr, "png_read_frame_head(): out of place fdAT");
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -653,7 +653,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_IDAT;
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
PNG_fdAt;
|
||||
PNG_fdAT;
|
||||
PNG_IEND;
|
||||
#endif
|
||||
const int png_pass_dsp_mask[7] = {0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};
|
||||
@ -810,7 +810,7 @@ png_read_row(png_structp png_ptr, png_bytep row, png_bytep dsp_row)
|
||||
{
|
||||
if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4))
|
||||
png_error(png_ptr, "Not enough image data");
|
||||
if (png_memcmp(png_ptr->chunk_name, png_fdAt, 4))
|
||||
if (png_memcmp(png_ptr->chunk_name, png_fdAT, 4))
|
||||
{
|
||||
png_warning(png_ptr, "Skipped (ignored) a chunk "
|
||||
"between APNG chunks");
|
||||
@ -1095,9 +1095,9 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
|
||||
PNG_zTXt;
|
||||
#endif
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
PNG_acTl;
|
||||
PNG_fcTl;
|
||||
PNG_fdAt;
|
||||
PNG_acTL;
|
||||
PNG_fcTL;
|
||||
PNG_fdAT;
|
||||
#endif
|
||||
#endif /* PNG_USE_LOCAL_ARRAYS */
|
||||
|
||||
@ -1206,12 +1206,12 @@ png_read_end(png_structp png_ptr, png_infop info_ptr)
|
||||
png_handle_iTXt(png_ptr, info_ptr, length);
|
||||
#endif
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_acTl, 4))
|
||||
png_handle_acTl(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTl, 4))
|
||||
png_handle_fcTl(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAt, 4))
|
||||
png_handle_fdAt(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_acTL, 4))
|
||||
png_handle_acTL(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fcTL, 4))
|
||||
png_handle_fcTL(png_ptr, info_ptr, length);
|
||||
else if (!png_memcmp(png_ptr->chunk_name, png_fdAT, 4))
|
||||
png_handle_fdAT(png_ptr, info_ptr, length);
|
||||
#endif
|
||||
else
|
||||
png_handle_unknown(png_ptr, info_ptr, length);
|
||||
|
||||
@ -364,7 +364,6 @@ png_handle_IHDR(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
interlace_type = buf[12];
|
||||
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
png_ptr->IHDR_crc = png_ptr->crc;
|
||||
png_ptr->first_frame_width = width;
|
||||
png_ptr->first_frame_height = height;
|
||||
#endif
|
||||
@ -527,19 +526,6 @@ png_handle_PLTE(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
|
||||
png_set_PLTE(png_ptr, info_ptr, palette, num);
|
||||
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
|
||||
{
|
||||
if (png_ptr->mode & PNG_HAVE_acTl)
|
||||
{
|
||||
if (png_ptr->crc != png_ptr->PLTE_crc)
|
||||
png_error(png_ptr, "PLTE checksum does not match that in acTl");
|
||||
}
|
||||
else
|
||||
png_ptr->PLTE_crc = png_ptr->crc;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(PNG_READ_tRNS_SUPPORTED)
|
||||
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
|
||||
{
|
||||
@ -2151,78 +2137,58 @@ png_handle_iTXt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
|
||||
#if defined(PNG_READ_APNG_SUPPORTED)
|
||||
void /* PRIVATE */
|
||||
png_handle_acTl(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_handle_acTL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
{
|
||||
png_byte data[16];
|
||||
png_byte data[8];
|
||||
png_uint_32 num_frames;
|
||||
png_uint_32 num_iterations;
|
||||
png_uint_32 didSet;
|
||||
png_uint_32 IHDR_crc;
|
||||
png_uint_32 PLTE_crc;
|
||||
|
||||
png_debug(1, "in png_handle_acTl\n");
|
||||
png_debug(1, "in png_handle_acTL\n");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
{
|
||||
png_error(png_ptr, "Missing IHDR before acTl");
|
||||
png_error(png_ptr, "Missing IHDR before acTL");
|
||||
}
|
||||
else if (png_ptr->mode & PNG_HAVE_IDAT)
|
||||
{
|
||||
png_warning(png_ptr, "Invalid acTl after IDAT skipped");
|
||||
png_warning(png_ptr, "Invalid acTL after IDAT skipped");
|
||||
png_crc_finish(png_ptr, length);
|
||||
return;
|
||||
}
|
||||
else if (png_ptr->mode & PNG_HAVE_acTl)
|
||||
else if (png_ptr->mode & PNG_HAVE_acTL)
|
||||
{
|
||||
png_warning(png_ptr, "Duplicate acTl skipped");
|
||||
png_warning(png_ptr, "Duplicate acTL skipped");
|
||||
png_crc_finish(png_ptr, length);
|
||||
return;
|
||||
}
|
||||
else if (length != 16)
|
||||
else if (length != 8)
|
||||
{
|
||||
png_warning(png_ptr, "acTl with invalid length skipped");
|
||||
png_warning(png_ptr, "acTL with invalid length skipped");
|
||||
png_crc_finish(png_ptr, length);
|
||||
return;
|
||||
}
|
||||
|
||||
png_crc_read(png_ptr, data, 16);
|
||||
png_crc_read(png_ptr, data, 8);
|
||||
png_crc_finish(png_ptr, 0);
|
||||
|
||||
num_frames = png_get_uint_31(png_ptr, data);
|
||||
num_iterations = png_get_uint_31(png_ptr, data + 4);
|
||||
IHDR_crc = png_get_uint_32(data + 8);
|
||||
PLTE_crc = png_get_uint_32(data + 12);
|
||||
|
||||
if (IHDR_crc != png_ptr->IHDR_crc)
|
||||
{
|
||||
png_warning(png_ptr, "acTl with invalid IHDR checksum skipped");
|
||||
return;
|
||||
}
|
||||
if (png_ptr->mode & PNG_HAVE_PLTE)
|
||||
{
|
||||
if (PLTE_crc != png_ptr->PLTE_crc)
|
||||
{
|
||||
png_warning(png_ptr, "acTl with invalid PLTE checksum skipped");
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
png_ptr->PLTE_crc = PLTE_crc;
|
||||
|
||||
/* the set function will do error checking on num_frames */
|
||||
didSet = png_set_acTl(png_ptr, info_ptr, num_frames, num_iterations);
|
||||
didSet = png_set_acTL(png_ptr, info_ptr, num_frames, num_iterations);
|
||||
if(didSet)
|
||||
{
|
||||
png_ptr->mode |= PNG_HAVE_acTl;
|
||||
png_ptr->mode |= PNG_HAVE_acTL;
|
||||
|
||||
/* if there is an fcTl this flag will be unset in png_handle_fcTl() */
|
||||
/* if there is an fcTL this flag will be unset in png_handle_fcTL() */
|
||||
if (num_frames > 1)
|
||||
png_ptr->apng_flags |= PNG_FIRST_FRAME_HIDDEN;
|
||||
}
|
||||
}
|
||||
|
||||
void /* PRIVATE */
|
||||
png_handle_fcTl(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_handle_fcTL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
{
|
||||
png_byte data[21];
|
||||
png_uint_32 width;
|
||||
@ -2233,30 +2199,30 @@ png_handle_fcTl(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_uint_16 delay_den;
|
||||
png_byte render_op;
|
||||
|
||||
png_debug(1, "in png_handle_fcTl\n");
|
||||
png_debug(1, "in png_handle_fcTL\n");
|
||||
|
||||
if (!(png_ptr->mode & PNG_HAVE_IHDR))
|
||||
{
|
||||
png_error(png_ptr, "Missing IHDR before fcTl");
|
||||
png_error(png_ptr, "Missing IHDR before fcTL");
|
||||
}
|
||||
else if (png_ptr->mode & PNG_HAVE_IDAT)
|
||||
{
|
||||
/* for any frames other then the first this message may be misleading,
|
||||
* but correct. PNG_HAVE_IDAT is unset before the frame head is read
|
||||
* i can't think of a better message */
|
||||
png_warning(png_ptr, "Invalid fcTl after IDAT skipped");
|
||||
png_warning(png_ptr, "Invalid fcTL after IDAT skipped");
|
||||
png_crc_finish(png_ptr, length);
|
||||
return;
|
||||
}
|
||||
else if (png_ptr->mode & PNG_HAVE_fcTl)
|
||||
else if (png_ptr->mode & PNG_HAVE_fcTL)
|
||||
{
|
||||
png_warning(png_ptr, "Duplicate fcTl within one frame skipped");
|
||||
png_warning(png_ptr, "Duplicate fcTL within one frame skipped");
|
||||
png_crc_finish(png_ptr, length);
|
||||
return;
|
||||
}
|
||||
else if (length != 25)
|
||||
{
|
||||
png_warning(png_ptr, "fcTl with invalid length skipped");
|
||||
png_warning(png_ptr, "fcTL with invalid length skipped");
|
||||
png_crc_finish(png_ptr, length);
|
||||
return;
|
||||
}
|
||||
@ -2275,35 +2241,35 @@ png_handle_fcTl(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
render_op = data[20];
|
||||
|
||||
if (png_ptr->num_frames_read == 0 && (x_offset != 0 || y_offset != 0))
|
||||
png_error(png_ptr, "fcTl for the first frame must have zero offset");
|
||||
png_error(png_ptr, "fcTL for the first frame must have zero offset");
|
||||
if (png_ptr->num_frames_read == 0 &&
|
||||
(width != info_ptr->width || height != info_ptr->height))
|
||||
png_error(png_ptr, "size in first frame's fcTl must match "
|
||||
png_error(png_ptr, "size in first frame's fcTL must match "
|
||||
"the size in IHDR");
|
||||
|
||||
/* the set function will do more error checking */
|
||||
png_set_next_frame_fcTl(png_ptr, info_ptr, width, height,
|
||||
png_set_next_frame_fcTL(png_ptr, info_ptr, width, height,
|
||||
x_offset, y_offset, delay_num, delay_den,
|
||||
render_op);
|
||||
|
||||
png_read_reinit(png_ptr, info_ptr);
|
||||
|
||||
png_ptr->mode |= PNG_HAVE_fcTl;
|
||||
png_ptr->mode |= PNG_HAVE_fcTL;
|
||||
|
||||
png_ptr->apng_flags &= ~PNG_FIRST_FRAME_HIDDEN;
|
||||
}
|
||||
|
||||
void /* PRIVATE */
|
||||
png_handle_fdAt(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
png_handle_fdAT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length)
|
||||
{
|
||||
png_ensure_sequence_number(png_ptr, length);
|
||||
|
||||
/* This function is only called from png_read_end(), png_read_info(),
|
||||
* and png_push_read_chunk() which means that:
|
||||
* - the user doesn't want to read this frame
|
||||
* - or this is an out-of-place fdAt
|
||||
* - or this is an out-of-place fdAT
|
||||
* in either case it is safe to ignore the chunk with a warning */
|
||||
png_warning(png_ptr, "ignoring fdAt chunk");
|
||||
png_warning(png_ptr, "ignoring fdAT chunk");
|
||||
png_crc_finish(png_ptr, length - 4);
|
||||
}
|
||||
|
||||
@ -2314,13 +2280,13 @@ png_ensure_sequence_number(png_structp png_ptr, png_uint_32 length)
|
||||
png_uint_32 sequence_number;
|
||||
|
||||
if (length < 4)
|
||||
png_error(png_ptr, "invalid fcTl or fdAt chunk found");
|
||||
png_error(png_ptr, "invalid fcTL or fdAT chunk found");
|
||||
|
||||
png_crc_read(png_ptr, data, 4);
|
||||
sequence_number = png_get_uint_31(png_ptr, data);
|
||||
|
||||
if (sequence_number != png_ptr->next_seq_num)
|
||||
png_error(png_ptr, "fcTl or fdAt chunk with out-of-order sequence "
|
||||
png_error(png_ptr, "fcTL or fdAT chunk with out-of-order sequence "
|
||||
"number found");
|
||||
|
||||
png_ptr->next_seq_num++;
|
||||
|
||||
@ -364,7 +364,7 @@ png_set_IHDR(png_structp png_ptr, png_infop info_ptr,
|
||||
info_ptr->rowbytes = PNG_ROWBYTES(info_ptr->pixel_depth,width);
|
||||
|
||||
#if defined(PNG_APNG_SUPPORTED)
|
||||
/* for non-animated png. this may be overritten from an acTl chunk later */
|
||||
/* for non-animated png. this may be overritten from an acTL chunk later */
|
||||
info_ptr->num_frames = 1;
|
||||
#endif
|
||||
}
|
||||
@ -1000,34 +1000,34 @@ png_set_sPLT(png_structp png_ptr,
|
||||
|
||||
#if defined(PNG_APNG_SUPPORTED)
|
||||
png_uint_32 PNGAPI
|
||||
png_set_acTl(png_structp png_ptr, png_infop info_ptr,
|
||||
png_set_acTL(png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 num_frames, png_uint_32 num_iterations)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "acTl");
|
||||
png_debug1(1, "in %s storage function\n", "acTL");
|
||||
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Call to png_set_acTl() with NULL png_ptr "
|
||||
"Call to png_set_acTL() with NULL png_ptr "
|
||||
"or info_ptr ignored");
|
||||
return (0);
|
||||
}
|
||||
if(num_frames == 0)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set acTl with num_frames zero");
|
||||
"Ignoring attempt to set acTL with num_frames zero");
|
||||
return (0);
|
||||
}
|
||||
if(num_frames > PNG_UINT_31_MAX)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set acTl with num_frames > 2^31-1");
|
||||
"Ignoring attempt to set acTL with num_frames > 2^31-1");
|
||||
return (0);
|
||||
}
|
||||
if(num_iterations > PNG_UINT_31_MAX)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Ignoring attempt to set acTl with num_iterations "
|
||||
"Ignoring attempt to set acTL with num_iterations "
|
||||
"> 2^31-1");
|
||||
return (0);
|
||||
}
|
||||
@ -1035,30 +1035,30 @@ png_set_acTl(png_structp png_ptr, png_infop info_ptr,
|
||||
info_ptr->num_frames = num_frames;
|
||||
info_ptr->num_iterations = num_iterations;
|
||||
|
||||
info_ptr->valid |= PNG_INFO_acTl;
|
||||
info_ptr->valid |= PNG_INFO_acTL;
|
||||
|
||||
return (1);
|
||||
}
|
||||
|
||||
/* delay_num and delay_den can hold any values including zero */
|
||||
png_uint_32 PNGAPI
|
||||
png_set_next_frame_fcTl(png_structp png_ptr, png_infop info_ptr,
|
||||
png_set_next_frame_fcTL(png_structp png_ptr, png_infop info_ptr,
|
||||
png_uint_32 width, png_uint_32 height,
|
||||
png_uint_32 x_offset, png_uint_32 y_offset,
|
||||
png_uint_16 delay_num, png_uint_16 delay_den,
|
||||
png_byte render_op)
|
||||
{
|
||||
png_debug1(1, "in %s storage function\n", "fcTl");
|
||||
png_debug1(1, "in %s storage function\n", "fcTL");
|
||||
|
||||
if (png_ptr == NULL || info_ptr == NULL)
|
||||
{
|
||||
png_warning(png_ptr,
|
||||
"Call to png_set_fcTl() with NULL png_ptr or info_ptr "
|
||||
"Call to png_set_fcTL() with NULL png_ptr or info_ptr "
|
||||
"ignored");
|
||||
return (0);
|
||||
}
|
||||
|
||||
png_ensure_fcTl_is_valid(png_ptr, width, height, x_offset, y_offset,
|
||||
png_ensure_fcTL_is_valid(png_ptr, width, height, x_offset, y_offset,
|
||||
delay_num, delay_den, render_op);
|
||||
|
||||
info_ptr->next_frame_width = width;
|
||||
@ -1069,13 +1069,13 @@ png_set_next_frame_fcTl(png_structp png_ptr, png_infop info_ptr,
|
||||
info_ptr->next_frame_delay_den = delay_den;
|
||||
info_ptr->next_frame_render_op = render_op;
|
||||
|
||||
info_ptr->valid |= PNG_INFO_fcTl;
|
||||
info_ptr->valid |= PNG_INFO_fcTL;
|
||||
|
||||
return (1);
|
||||
}
|
||||
|
||||
void /* PRIVATE */
|
||||
png_ensure_fcTl_is_valid(png_structp png_ptr,
|
||||
png_ensure_fcTL_is_valid(png_structp png_ptr,
|
||||
png_uint_32 width, png_uint_32 height,
|
||||
png_uint_32 x_offset, png_uint_32 y_offset,
|
||||
png_uint_16 delay_num, png_uint_16 delay_den,
|
||||
@ -1086,16 +1086,16 @@ png_ensure_fcTl_is_valid(png_structp png_ptr,
|
||||
png_error(png_ptr, "width and/or height for a frame greater than"
|
||||
"the ones in IHDR");
|
||||
if (width > PNG_UINT_31_MAX)
|
||||
png_error(png_ptr, "invalid width in fcTl (> 2^31-1)");
|
||||
png_error(png_ptr, "invalid width in fcTL (> 2^31-1)");
|
||||
if (height > PNG_UINT_31_MAX)
|
||||
png_error(png_ptr, "invalid height in fcTl (> 2^31-1)");
|
||||
png_error(png_ptr, "invalid height in fcTL (> 2^31-1)");
|
||||
if (x_offset > PNG_UINT_31_MAX)
|
||||
png_error(png_ptr, "invalid x_offset in fcTl (> 2^31-1)");
|
||||
png_error(png_ptr, "invalid x_offset in fcTL (> 2^31-1)");
|
||||
if (y_offset > PNG_UINT_31_MAX)
|
||||
png_error(png_ptr, "invalid y_offset in fcTl (> 2^31-1)");
|
||||
png_error(png_ptr, "invalid y_offset in fcTL (> 2^31-1)");
|
||||
if (render_op & 0xF0)
|
||||
/* Bits 4 through 7 are reserved and must be set to zero (APNG spec) */
|
||||
png_error(png_ptr, "invalid render_op in fcTl");
|
||||
png_error(png_ptr, "invalid render_op in fcTL");
|
||||
if (render_op & 0x08 && png_ptr->color_type == PNG_COLOR_TYPE_GRAY)
|
||||
png_error(png_ptr, "APNG_RENDER_OP_BLEND_FLAG is not valid for "
|
||||
"color type 'greyscale without alpha'");
|
||||
@ -1105,11 +1105,11 @@ png_ensure_fcTl_is_valid(png_structp png_ptr,
|
||||
png_error(png_ptr, "APNG_RENDER_OP_BLEND_FLAG is not valid for "
|
||||
"color type 'truecolor without alpha'");
|
||||
if (!(render_op & PNG_RENDER_OP_DISPOSE_MASK))
|
||||
png_error(png_ptr, "no DISPOSE_ flag found in fcTl");
|
||||
png_error(png_ptr, "no DISPOSE_ flag found in fcTL");
|
||||
if ( (render_op & PNG_RENDER_OP_DISPOSE_MASK) != PNG_RENDER_OP_DISPOSE_NONE &&
|
||||
(render_op & PNG_RENDER_OP_DISPOSE_MASK) != PNG_RENDER_OP_DISPOSE_BACKGROUND &&
|
||||
(render_op & PNG_RENDER_OP_DISPOSE_MASK) != PNG_RENDER_OP_DISPOSE_PREVIOUS)
|
||||
png_error(png_ptr, "multiple DISPOSE_ flags set in fcTl");
|
||||
png_error(png_ptr, "multiple DISPOSE_ flags set in fcTL");
|
||||
}
|
||||
#endif /* PNG_APNG_SUPPORTED */
|
||||
|
||||
|
||||
@ -262,8 +262,8 @@ png_write_info(png_structp png_ptr, png_infop info_ptr)
|
||||
}
|
||||
#endif
|
||||
#if defined(PNG_WRITE_APNG_SUPPORTED)
|
||||
if (info_ptr->valid & PNG_INFO_acTl)
|
||||
png_write_acTl(png_ptr, info_ptr->num_frames, info_ptr->num_iterations);
|
||||
if (info_ptr->valid & PNG_INFO_acTL)
|
||||
png_write_acTL(png_ptr, info_ptr->num_frames, info_ptr->num_iterations);
|
||||
#endif
|
||||
#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
|
||||
if (info_ptr->unknown_chunks_num)
|
||||
@ -1531,15 +1531,15 @@ png_write_frame_head(png_structp png_ptr, png_infop info_ptr,
|
||||
|
||||
/* there is a chance this has been set after png_write_info was called,
|
||||
* so it would be set but not written. is there a way to be sure? */
|
||||
if (!(info_ptr->valid & PNG_INFO_acTl))
|
||||
png_error(png_ptr, "png_write_frame_head(): acTl not set");
|
||||
if (!(info_ptr->valid & PNG_INFO_acTL))
|
||||
png_error(png_ptr, "png_write_frame_head(): acTL not set");
|
||||
|
||||
png_write_reset(png_ptr);
|
||||
|
||||
png_write_reinit(png_ptr, info_ptr, width, height);
|
||||
|
||||
if ( !(png_ptr->num_frames_written == 0 && first_frame_hidden) )
|
||||
png_write_fcTl(png_ptr, width, height, x_offset, y_offset,
|
||||
png_write_fcTL(png_ptr, width, height, x_offset, y_offset,
|
||||
delay_num, delay_den, render_op);
|
||||
}
|
||||
|
||||
|
||||
@ -492,7 +492,6 @@ png_write_IHDR(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
|
||||
png_write_chunk(png_ptr, (png_bytep)png_IHDR, buf, (png_size_t)13);
|
||||
|
||||
#if defined(PNG_WRITE_APNG_SUPPORTED)
|
||||
png_ptr->IHDR_crc = png_ptr->crc;
|
||||
png_ptr->first_frame_width = width;
|
||||
png_ptr->first_frame_height = height;
|
||||
#endif
|
||||
@ -600,13 +599,6 @@ png_write_PLTE(png_structp png_ptr, png_colorp palette, png_uint_32 num_pal)
|
||||
#endif
|
||||
png_write_chunk_end(png_ptr);
|
||||
png_ptr->mode |= PNG_HAVE_PLTE;
|
||||
|
||||
#if defined(PNG_WRITE_APNG_SUPPORTED)
|
||||
if (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
|
||||
{
|
||||
png_ptr->PLTE_crc = png_ptr->crc;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/* write an IDAT chunk */
|
||||
@ -616,7 +608,7 @@ png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_IDAT;
|
||||
#if defined(PNG_WRITE_APNG_SUPPORTED)
|
||||
PNG_fdAt;
|
||||
PNG_fdAT;
|
||||
#endif
|
||||
#endif
|
||||
png_debug(1, "in png_write_IDAT\n");
|
||||
@ -669,7 +661,7 @@ png_write_IDAT(png_structp png_ptr, png_bytep data, png_size_t length)
|
||||
{
|
||||
png_byte buf[4];
|
||||
|
||||
png_write_chunk_start(png_ptr, (png_bytep)png_fdAt, 4 + length);
|
||||
png_write_chunk_start(png_ptr, (png_bytep)png_fdAT, 4 + length);
|
||||
|
||||
png_save_uint_32(buf, png_ptr->next_seq_num);
|
||||
png_write_chunk_data(png_ptr, buf, 4);
|
||||
@ -1732,57 +1724,55 @@ png_write_tIME(png_structp png_ptr, png_timep mod_time)
|
||||
|
||||
#if defined(PNG_WRITE_APNG_SUPPORTED)
|
||||
void /* PRIVATE */
|
||||
png_write_acTl(png_structp png_ptr,
|
||||
png_write_acTL(png_structp png_ptr,
|
||||
png_uint_32 num_frames, png_uint_32 num_iterations)
|
||||
{
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_acTl;
|
||||
PNG_acTL;
|
||||
#endif
|
||||
png_byte data[16];
|
||||
|
||||
png_debug(1, "in png_write_acTl\n");
|
||||
png_debug(1, "in png_write_acTL\n");
|
||||
|
||||
if (num_frames == 0)
|
||||
png_error(png_ptr, "png_write_acTl: invalid number of frames (0)");
|
||||
png_error(png_ptr, "png_write_acTL: invalid number of frames (0)");
|
||||
if (num_frames > PNG_UINT_31_MAX)
|
||||
png_error(png_ptr, "png_write_acTl: invalid number of frames "
|
||||
png_error(png_ptr, "png_write_acTL: invalid number of frames "
|
||||
"(> 2^31-1)");
|
||||
if (num_iterations > PNG_UINT_31_MAX)
|
||||
png_error(png_ptr, "png_write_acTl: invalid number of iterations "
|
||||
png_error(png_ptr, "png_write_acTL: invalid number of iterations "
|
||||
"(> 2^31-1)");
|
||||
|
||||
png_ptr->num_frames_to_write = num_frames;
|
||||
|
||||
png_save_uint_32(data, num_frames);
|
||||
png_save_uint_32(data + 4, num_iterations);
|
||||
png_save_uint_32(data + 8, png_ptr->IHDR_crc);
|
||||
png_save_uint_32(data + 12, png_ptr->PLTE_crc);
|
||||
|
||||
png_write_chunk(png_ptr, (png_bytep)png_acTl, data, (png_size_t)16);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_acTL, data, (png_size_t)8);
|
||||
}
|
||||
|
||||
void /* PRIVATE */
|
||||
png_write_fcTl(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
|
||||
png_write_fcTL(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
|
||||
png_uint_32 x_offset, png_uint_32 y_offset,
|
||||
png_uint_16 delay_num, png_uint_16 delay_den, png_byte render_op)
|
||||
{
|
||||
#ifdef PNG_USE_LOCAL_ARRAYS
|
||||
PNG_fcTl;
|
||||
PNG_fcTL;
|
||||
#endif
|
||||
png_byte data[25];
|
||||
|
||||
png_debug(1, "in png_write_fcTl\n");
|
||||
png_debug(1, "in png_write_fcTL\n");
|
||||
|
||||
if (png_ptr->num_frames_written == 0 && (x_offset != 0 || y_offset != 0))
|
||||
png_error(png_ptr, "x and/or y offset for the first frame aren't 0\n");
|
||||
if (png_ptr->num_frames_written == 0 &&
|
||||
(width != png_ptr->first_frame_width ||
|
||||
height != png_ptr->first_frame_height))
|
||||
png_error(png_ptr, "width and/or height in the first frame's fcTl "
|
||||
png_error(png_ptr, "width and/or height in the first frame's fcTL "
|
||||
"don't match the ones in IHDR\n");
|
||||
|
||||
/* more error checking */
|
||||
png_ensure_fcTl_is_valid(png_ptr, width, height, x_offset, y_offset,
|
||||
png_ensure_fcTL_is_valid(png_ptr, width, height, x_offset, y_offset,
|
||||
delay_num, delay_den, render_op);
|
||||
|
||||
png_save_uint_32(data, png_ptr->next_seq_num);
|
||||
@ -1794,7 +1784,7 @@ png_write_fcTl(png_structp png_ptr, png_uint_32 width, png_uint_32 height,
|
||||
png_save_uint_16(data + 22, delay_den);
|
||||
data[24] = render_op;
|
||||
|
||||
png_write_chunk(png_ptr, (png_bytep)png_fcTl, data, (png_size_t)25);
|
||||
png_write_chunk(png_ptr, (png_bytep)png_fcTL, data, (png_size_t)25);
|
||||
|
||||
png_ptr->next_seq_num++;
|
||||
}
|
||||
@ -2877,7 +2867,7 @@ png_write_reinit(png_structp png_ptr, png_infop info_ptr,
|
||||
if (png_ptr->num_frames_written == 0 &&
|
||||
(width != png_ptr->first_frame_width ||
|
||||
height != png_ptr->first_frame_height))
|
||||
png_error(png_ptr, "width and/or height in the first frame's fcTl "
|
||||
png_error(png_ptr, "width and/or height in the first frame's fcTL "
|
||||
"don't match the ones in IHDR\n");
|
||||
if (width > png_ptr->first_frame_width ||
|
||||
height > png_ptr->first_frame_height)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user