Index: libpng-1.2.12/pngpread.c =================================================================== --- libpng-1.2.12/pngpread.c (révision 54) +++ libpng-1.2.12/pngpread.c (copie de travail) @@ -190,6 +190,12 @@ #if defined(PNG_READ_zTXt_SUPPORTED) PNG_zTXt; #endif +#if defined(PNG_READ_APNG_SUPPORTED) + PNG_acTL; + PNG_fcTL; + PNG_fdAT; + PNG_feND; +#endif #endif /* PNG_USE_LOCAL_ARRAYS */ /* First we make sure we have enough data for the 4 byte chunk name * and the 4 byte chunk length before proceeding with decoding the @@ -213,7 +219,76 @@ png_crc_read(png_ptr, png_ptr->chunk_name, 4); png_ptr->mode |= PNG_HAVE_CHUNK_HEADER; } - + +#if defined(PNG_READ_APNG_SUPPORTED) + /* read the fdAT contents */ + if (png_ptr->apng_flags & PNG_INSIDE_fdAT) + { + if (!(png_ptr->mode & PNG_HAVE_fcTL)) + { + if (png_memcmp(png_ptr->chunk_name, png_fcTL, 4)) + png_error(png_ptr, "unexpected chunk type when fcTL expected " + "inside fdAT"); + 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_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; + if (png_ptr->frame_fn != NULL) + png_ptr->frame_fn(png_ptr, png_ptr->num_frames_read); + return; + } + else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) + { + if (!(png_ptr->mode & PNG_HAVE_IDAT)) + { + /* frame data follows */ + png_ptr->idat_size = png_ptr->push_length; + png_ptr->mode |= PNG_HAVE_IDAT; + png_ptr->process_mode = PNG_READ_IDAT_MODE; + return; + } + else + { + /* skip trailing IDATs */ + if (png_ptr->push_length + 4 > png_ptr->buffer_size) + { + png_push_save_buffer(png_ptr); + return; + } + png_push_crc_skip(png_ptr, png_ptr->push_length); + png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; + return; + } + } + else if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_feND, 4)) + { + png_byte garbage[4]; + + if (!(png_ptr->mode & PNG_HAVE_IDAT)) + png_error(png_ptr, "frame data inside fdAT missing"); + if (png_ptr->push_length != 0) + png_error(png_ptr, "feND with non-zero length"); + + /* wait for feND crc and fdAT crc */ + if (png_ptr->buffer_size < 8) + { + png_push_save_buffer(png_ptr); + return; + } + + png_push_crc_skip(png_ptr, png_ptr->push_length); + png_read_data(png_ptr, garbage, 4); /* fdAT crc */ + + png_ptr->apng_flags &= ~PNG_INSIDE_fdAT; + png_ptr->mode &= ~PNG_HAVE_CHUNK_HEADER; + return; + } + } +#endif /* PNG_READ_APNG_SUPPORTED */ + if (!png_memcmp(png_ptr->chunk_name, (png_bytep)png_IDAT, 4)) if(png_ptr->mode & PNG_AFTER_IDAT) png_ptr->mode |= PNG_HAVE_CHUNK_AFTER_IDAT; @@ -488,6 +563,43 @@ png_push_handle_iTXt(png_ptr, info_ptr, png_ptr->push_length); } #endif +#if defined(PNG_READ_APNG_SUPPORTED) + 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); + } + 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); + } + else if (!png_memcmp(png_ptr->chunk_name, png_fdAT, 4)) + { + if (png_ptr->num_frames_read == 0) + png_error(png_ptr, "out of place fdAT"); + png_progressive_read_reset(png_ptr); + png_ptr->apng_flags |= PNG_INSIDE_fdAT; + png_ptr->mode &= ~PNG_HAVE_fcTL; + } + else if (!png_memcmp(png_ptr->chunk_name, png_feND, 4)) + { + if (png_ptr->push_length + 4 > png_ptr->buffer_size) + { + png_push_save_buffer(png_ptr); + return; + } + png_handle_feND(png_ptr, info_ptr, png_ptr->push_length); + } +#endif /* PNG_READ_APNG_SUPPORTED */ else { if (png_ptr->push_length + 4 > png_ptr->buffer_size) @@ -680,6 +792,11 @@ png_ptr->process_mode = PNG_READ_CHUNK_MODE; if (!(png_ptr->flags & PNG_FLAG_ZLIB_FINISHED)) png_error(png_ptr, "Not enough compressed data"); +#if defined(PNG_READ_APNG_SUPPORTED) + //~ if (png_ptr->frame_fn != NULL) + //~ png_ptr->frame_fn(png_ptr, png_ptr->num_frames_read); + png_ptr->num_frames_read++; +#endif return; } @@ -1570,6 +1687,15 @@ png_set_read_fn(png_ptr, progressive_ptr, png_push_fill_buffer); } +#if defined(PNG_READ_APNG_SUPPORTED) +void PNGAPI +png_set_progressive_frame_fn(png_structp png_ptr, + png_progressive_frame_ptr frame_fn) +{ + png_ptr->frame_fn = frame_fn; +} +#endif + png_voidp PNGAPI png_get_progressive_ptr(png_structp png_ptr) { Index: libpng-1.2.12/pngrutil.c =================================================================== --- libpng-1.2.12/pngrutil.c (révision 54) +++ libpng-1.2.12/pngrutil.c (copie de travail) @@ -2130,6 +2130,140 @@ } #endif +#if defined(PNG_READ_APNG_SUPPORTED) +void /* PRIVATE */ +png_handle_acTL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +{ + png_byte data[8]; + png_uint_32 num_frames; + png_uint_32 num_iterations; + png_uint_32 didSet; + + png_debug(1, "in png_handle_acTL\n"); + + if (!(png_ptr->mode & PNG_HAVE_IHDR)) + { + 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_crc_finish(png_ptr, length); + return; + } + else if (png_ptr->mode & PNG_HAVE_acTL) + { + png_warning(png_ptr, "Duplicate acTL skipped"); + png_crc_finish(png_ptr, length); + return; + } + else if (length != 8) + { + png_warning(png_ptr, "acTL with invalid length skipped"); + png_crc_finish(png_ptr, length); + return; + } + + 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); + + /* the set function will do error checking on num_frames */ + didSet = png_set_acTL(png_ptr, info_ptr, num_frames, num_iterations); + if(didSet) + png_ptr->mode |= PNG_HAVE_acTL; +} + +void /* PRIVATE */ +png_handle_fcTL(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +{ + png_byte data[17]; + png_uint_32 sequence_number; + 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_uint_32 didSet; + + png_debug(1, "in png_handle_fcTL\n"); + + if (!(png_ptr->mode & PNG_HAVE_IHDR)) + { + 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 when the frame head is read + * i can't think of a better message */ + png_warning(png_ptr, "Invalid fcTL after IDAT skipped"); + png_crc_finish(png_ptr, length); + return; + } + else if (png_ptr->mode & PNG_HAVE_fcTL) + { + png_warning(png_ptr, "Duplicate fcTL within one frame skipped"); + png_crc_finish(png_ptr, length); + return; + } + else if (length != 17) + { + png_warning(png_ptr, "fcTL with invalid length skipped"); + png_crc_finish(png_ptr, length); + return; + } + + png_crc_read(png_ptr, data, 17); + png_crc_finish(png_ptr, 0); + + sequence_number = png_get_uint_31(png_ptr, data); + x_offset = png_get_uint_31(png_ptr, data + 4); + y_offset = png_get_uint_31(png_ptr, data + 8); + delay_num = png_get_uint_16(data + 12); + delay_den = png_get_uint_16(data + 14); + render_op = data[16]; + + if (sequence_number != png_ptr->num_frames_read) + png_error(png_ptr, + "png_handle_fcTL: out-of-sequence frame"); + if (png_ptr->num_frames_read == 0 && (x_offset != 0 || y_offset != 0)) + png_error(png_ptr, + "png_handle_fcTL: fcTL for the first frame with " + "non-zero x_offset or y_offset not allowed"); + + /* the set function will do error checking on render_op */ + didSet = png_set_next_frame_fcTL(png_ptr, info_ptr, x_offset, y_offset, + delay_num, delay_den, render_op); + if(!didSet) + png_error(png_ptr, "invalid fcTL chunk"); + + png_ptr->mode |= PNG_HAVE_fcTL; +} + +void /* PRIVATE */ +png_handle_fdAT(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +{ + /* this function is only called from png_read_end() and png_read_info() + * which means that: + * - the user doesn't want to read this frame + * - 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_crc_finish(png_ptr, length); +} + +void /* PRIVATE */ +png_handle_feND(png_structp png_ptr, png_infop info_ptr, png_uint_32 length) +{ + /* feND must always be inside fdAT, so if got here, it's a problem */ + png_warning(png_ptr, "ignoring out-of-place feND chunk"); + png_crc_finish(png_ptr, length); +} +#endif /* PNG_READ_APNG_SUPPORTED */ + /* This function is called when we haven't found a handler for a chunk. If there isn't a problem with the chunk itself (ie bad chunk name, CRC, or a critical chunk), the chunk is silently ignored @@ -3094,8 +3228,10 @@ if (row_bytes > (png_uint_32)65536L) png_error(png_ptr, "This image requires a row greater than 64KB"); #endif - png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); - png_ptr->row_buf = png_ptr->big_row_buf+32; + if (png_ptr->big_row_buf == NULL) + png_ptr->big_row_buf = (png_bytep)png_malloc(png_ptr, row_bytes+64); + if (png_ptr->row_buf == NULL) + png_ptr->row_buf = png_ptr->big_row_buf+32; #if defined(PNG_DEBUG) && defined(PNG_USE_PNGGCCRD) png_ptr->row_buf_size = row_bytes; #endif @@ -3120,4 +3256,76 @@ png_ptr->flags |= PNG_FLAG_ROW_INIT; } + +#if defined(PNG_READ_APNG_SUPPORTED) +/* This function is to be called after the main IDAT set has been read and + * before a new IDAT is read. It resets some parts of png_ptr + * to make them usable by the read functions again */ +void /* PRIVATE */ +png_read_reset(png_structp png_ptr) +{ + png_ptr->mode &= ~PNG_HAVE_IDAT; + png_ptr->mode &= ~PNG_AFTER_IDAT; + png_ptr->row_number = 0; + png_ptr->pass = 0; + png_ptr->flags &= ~PNG_FLAG_ROW_INIT; +} + +/* same as png_read_reset() but for the progressive reader */ +void /* PRIVATE */ +png_progressive_read_reset(png_structp png_ptr) +{ +#ifdef PNG_USE_LOCAL_ARRAYS + /* start of interlace block */ + const int FARDATA png_pass_start[] = {0, 4, 0, 2, 0, 1, 0}; + + /* offset to next interlace block */ + const int FARDATA png_pass_inc[] = {8, 8, 4, 4, 2, 2, 1}; + + /* start of interlace block in the y direction */ + const int FARDATA png_pass_ystart[] = {0, 0, 4, 0, 2, 0, 1}; + + /* offset to next interlace block in the y direction */ + const int FARDATA png_pass_yinc[] = {8, 8, 8, 4, 4, 2, 2}; +#endif + png_uint_32 row_bytes; + + png_read_reset(png_ptr); + + if (png_ptr->interlaced) + { + if (!(png_ptr->transformations & PNG_INTERLACE)) + png_ptr->num_rows = (png_ptr->height + png_pass_yinc[0] - 1 - + png_pass_ystart[0]) / png_pass_yinc[0]; + else + png_ptr->num_rows = png_ptr->height; + + png_ptr->iwidth = (png_ptr->width + + png_pass_inc[png_ptr->pass] - 1 - + png_pass_start[png_ptr->pass]) / + png_pass_inc[png_ptr->pass]; + + row_bytes = PNG_ROWBYTES(png_ptr->pixel_depth,png_ptr->iwidth) + 1; + + png_ptr->irowbytes = (png_size_t)row_bytes; + if((png_uint_32)png_ptr->irowbytes != row_bytes) + png_error(png_ptr, "png_progressive_read_reset(): Rowbytes " + "overflow"); + } + else + { + png_ptr->num_rows = png_ptr->height; + png_ptr->iwidth = png_ptr->width; + png_ptr->irowbytes = png_ptr->rowbytes + 1; + } + + png_ptr->flags &= ~PNG_FLAG_ZLIB_FINISHED; + if (inflateReset(&(png_ptr->zstream)) != Z_OK) + png_error(png_ptr, "inflateReset failed"); + png_ptr->zstream.avail_in = 0; + png_ptr->zstream.next_in = 0; + png_ptr->zstream.next_out = png_ptr->row_buf; + png_ptr->zstream.avail_out = (uInt)png_ptr->irowbytes; +} +#endif /* PNG_READ_APNG_SUPPORTED */ #endif /* PNG_READ_SUPPORTED */ Index: libpng-1.2.12/pngread.c =================================================================== --- libpng-1.2.12/pngread.c (révision 54) +++ libpng-1.2.12/pngread.c (copie de travail) @@ -397,6 +397,12 @@ #if defined(PNG_READ_zTXt_SUPPORTED) PNG_zTXt; #endif +#if defined(PNG_READ_APNG_SUPPORTED) + PNG_acTL; + PNG_fcTL; + PNG_fdAT; + png_feND; +#endif #endif /* PNG_USE_LOCAL_ARRAYS */ png_byte chunk_length[4]; png_uint_32 length; @@ -522,12 +528,116 @@ else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) 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_feND, 4)) + png_handle_feND(png_ptr, info_ptr, length); +#endif else png_handle_unknown(png_ptr, info_ptr, length); } } #endif /* PNG_NO_SEQUENTIAL_READ_SUPPORTED */ +#if defined(PNG_READ_APNG_SUPPORTED) +void PNGAPI +png_read_frame_head(png_structp png_ptr, png_infop info_ptr) +{ + png_byte garbage[4]; + png_byte have_chunk_after_IDAT; + png_byte have_feND; + + png_debug(0, "Reading frame head\n"); + + if (!(png_ptr->mode & PNG_HAVE_acTL)) + png_error(png_ptr, "attempt to png_read_frame_head() but " + "no acTL present"); + + /* do nothing for the main IDAT */ + if (png_ptr->num_frames_read == 0) + return; + + png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ + + png_read_reset(png_ptr); + png_ptr->mode &= ~PNG_HAVE_fcTL; + + have_chunk_after_IDAT = 0; + have_feND = 0; + for (;;) + { +#ifdef PNG_USE_LOCAL_ARRAYS + PNG_IDAT; + PNG_fdAT; + PNG_fcTL; + PNG_feND; +#endif + png_byte chunk_length[4]; + png_uint_32 length; + + png_read_data(png_ptr, chunk_length, 4); + length = png_get_uint_31(png_ptr,chunk_length); + + png_reset_crc(png_ptr); + png_crc_read(png_ptr, png_ptr->chunk_name, 4); + + if (!png_memcmp(png_ptr->chunk_name, png_feND, 4)) + { + if (have_feND || png_ptr->num_frames_read == 0) + png_error(png_ptr, "out of place feND chunk"); + if (length != 0) + png_error(png_ptr, "feND with non-zero length"); + png_crc_finish(png_ptr, length); + png_read_data(png_ptr, garbage, 4); /* fdAT crc */ + have_feND = 1; + have_chunk_after_IDAT = 1; + } + else if (!png_memcmp(png_ptr->chunk_name, png_fdAT, 4)) + { + if (png_ptr->num_frames_read > 1 && !have_feND) + png_error(png_ptr, "missing feND chunk"); + + png_read_data(png_ptr, chunk_length, 4); + length = png_get_uint_31(png_ptr, chunk_length); + + png_reset_crc(png_ptr); + png_crc_read(png_ptr, png_ptr->chunk_name, 4); + if (png_memcmp(png_ptr->chunk_name, png_fcTL, 4)) + png_error(png_ptr, "expected fcTL inside an fdAT not found"); + + png_handle_fcTL(png_ptr, info_ptr, length); + + png_read_data(png_ptr, chunk_length, 4); + length = png_get_uint_31(png_ptr, chunk_length); + + png_reset_crc(png_ptr); + png_crc_read(png_ptr, png_ptr->chunk_name, 4); + if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) + png_error(png_ptr, "expected IDAT inside an fdAT not found"); + + png_ptr->idat_size = length; + png_ptr->mode |= PNG_HAVE_IDAT; + + break; + } + else if (!png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) + { + /* discard trailing IDATs */ + if (have_chunk_after_IDAT) + png_error(png_ptr, "png_read_frame_head(): out of place IDAT"); + png_crc_finish(png_ptr, length); + } + else + png_error(png_ptr, "png_read_frame_head(): unexpected chunk type"); + } +} +#endif /* PNG_READ_APNG_SUPPORTED */ + /* optional call to update the users info_ptr structure */ void PNGAPI png_read_update_info(png_structp png_ptr, png_infop info_ptr) @@ -719,6 +829,9 @@ png_error(png_ptr, "Extra compressed data"); png_ptr->mode |= PNG_AFTER_IDAT; png_ptr->flags |= PNG_FLAG_ZLIB_FINISHED; +#if defined(PNG_READ_APNG_SUPPORTED) + png_ptr->num_frames_read++; +#endif break; } if (ret != Z_OK) @@ -908,10 +1021,19 @@ { png_byte chunk_length[4]; png_uint_32 length; +#if defined(PNG_READ_APNG_SUPPORTED) + png_byte garbage[4]; + png_byte have_chunk_after_IDAT; + png_byte have_feND; +#endif png_debug(1, "in png_read_end\n"); png_crc_finish(png_ptr, 0); /* Finish off CRC from last IDAT chunk */ - + +#if defined(PNG_READ_APNG_SUPPORTED) + have_chunk_after_IDAT = 0; + have_feND = 0; +#endif do { #ifdef PNG_USE_LOCAL_ARRAYS @@ -970,6 +1092,12 @@ #if defined(PNG_READ_zTXt_SUPPORTED) PNG_zTXt; #endif +#if defined(PNG_READ_APNG_SUPPORTED) + PNG_acTL; + PNG_fcTL; + PNG_fdAT; + PNG_feND; +#endif #endif /* PNG_USE_LOCAL_ARRAYS */ png_read_data(png_ptr, chunk_length, 4); @@ -980,6 +1108,16 @@ png_debug1(0, "Reading %s chunk.\n", png_ptr->chunk_name); +#if defined(PNG_READ_APNG_SUPPORTED) + if (png_memcmp(png_ptr->chunk_name, png_IDAT, 4)) + { + if (png_ptr->num_frames_read > 1 && !have_feND && + png_memcmp(png_ptr->chunk_name, png_feND, 4)) + png_error(png_ptr, "missing feND chunk"); + have_chunk_after_IDAT = 1; + } +#endif + if (!png_memcmp(png_ptr->chunk_name, png_IHDR, 4)) png_handle_IHDR(png_ptr, info_ptr, length); else if (!png_memcmp(png_ptr->chunk_name, png_IEND, 4)) @@ -1004,7 +1142,11 @@ */ if ((length > 0) || (png_ptr->mode & PNG_HAVE_CHUNK_AFTER_IDAT)) png_error(png_ptr, "Too many IDAT's found"); +#if defined(PNG_READ_APNG_SUPPORTED) + if (have_chunk_after_IDAT) + png_error(png_ptr, "out of place IDAT"); png_crc_finish(png_ptr, length); +#endif } else if (!png_memcmp(png_ptr->chunk_name, png_PLTE, 4)) png_handle_PLTE(png_ptr, info_ptr, length); @@ -1076,6 +1218,24 @@ else if (!png_memcmp(png_ptr->chunk_name, png_iTXt, 4)) 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_feND, 4)) + { + if (have_feND) + png_error(png_ptr, "out of place feND chunk"); + if (length != 0) + png_error(png_ptr, "feND with non-zero length"); + png_crc_finish(png_ptr, length); + png_read_data(png_ptr, garbage, 4); /* fdAT crc */ + have_feND = 1; + } +#endif else png_handle_unknown(png_ptr, info_ptr, length); } while (!(png_ptr->mode & PNG_HAVE_IEND)); Index: libpng-1.2.12/png.c =================================================================== --- libpng-1.2.12/png.c (révision 54) +++ libpng-1.2.12/png.c (copie de travail) @@ -51,6 +51,10 @@ PNG_tIME; PNG_tRNS; PNG_zTXt; +PNG_acTL; +PNG_fcTL; +PNG_fdAT; +PNG_feND; #ifdef PNG_READ_SUPPORTED /* arrays to facilitate easy interlacing - use pass (0 - 6) as index */ Index: libpng-1.2.12/pngget.c =================================================================== --- libpng-1.2.12/pngget.c (révision 54) +++ libpng-1.2.12/pngget.c (copie de travail) <<<<<<< .mine @@ -794,6 +794,114 @@ ======= @@ -794,6 +794,120 @@ >>>>>>> .r66 } #endif +#if defined(PNG_APNG_SUPPORTED) +png_uint_32 PNGAPI +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"); + + if (png_ptr != NULL && info_ptr != NULL && + (info_ptr->valid & PNG_INFO_acTL) && + num_frames != NULL && num_iterations != NULL) + { + *num_frames = info_ptr->num_frames; + *num_iterations = info_ptr->num_iterations; + return (1); + } + + return (0); +} + +png_uint_32 PNGAPI +png_get_num_frames(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_get_num_frames()\n"); + + if (png_ptr != NULL && info_ptr != NULL) + return (info_ptr->num_frames); + return (0); +} + +png_uint_32 PNGAPI +png_get_num_iterations(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_get_num_iterations()\n"); + + if (png_ptr != NULL && info_ptr != NULL) + return (info_ptr->num_iterations); + return (0); +} + +png_uint_32 PNGAPI +png_get_next_frame_fcTL(png_structp png_ptr, png_infop info_ptr, + 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"); + + if (png_ptr != NULL && info_ptr != NULL && + (info_ptr->valid & PNG_INFO_fcTL) && + x_offset != NULL && x_offset != NULL && + delay_num != NULL && delay_den != NULL && render_op != NULL) + { + *x_offset = info_ptr->next_frame_x_offset; + *y_offset = info_ptr->next_frame_y_offset; + *delay_num = info_ptr->next_frame_delay_num; + *delay_den = info_ptr->next_frame_delay_den; + *render_op = info_ptr->next_frame_render_op; + return (1); + } + + return (0); +} + +png_uint_32 PNGAPI +png_get_next_frame_x_offset(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_get_next_frame_x_offset()\n"); + + if (png_ptr != NULL && info_ptr != NULL) + return (info_ptr->next_frame_x_offset); + return (0); +} + +png_uint_32 PNGAPI +png_get_next_frame_y_offset(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_get_next_frame_y_offset()\n"); + + if (png_ptr != NULL && info_ptr != NULL) + return (info_ptr->next_frame_y_offset); + return (0); +} + +png_uint_16 PNGAPI +png_get_next_frame_delay_num(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_get_next_frame_delay_num()\n"); + + if (png_ptr != NULL && info_ptr != NULL) + return (info_ptr->next_frame_delay_num); + return (0); +} + +png_uint_16 PNGAPI +png_get_next_frame_delay_den(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_get_next_frame_delay_den()\n"); + + if (png_ptr != NULL && info_ptr != NULL) + return (info_ptr->next_frame_delay_den); + return (0); +} + +png_byte PNGAPI +png_get_next_frame_render_op(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_get_next_frame_render_op()\n"); + + if (png_ptr != NULL && info_ptr != NULL) + return (info_ptr->next_frame_render_op); + return (0); +} + +png_byte PNGAPI +png_next_frame_is_hidden(png_structp png_ptr, png_infop info_ptr) +{ + png_debug(1, "in png_next_frame_is_hidden()\n"); + + return info_ptr->next_frame_render_op & 0x10; +} +#endif /* PNG_APNG_SUPPORTED */ + #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) png_uint_32 PNGAPI png_get_unknown_chunks(png_structp png_ptr, png_infop info_ptr, Index: libpng-1.2.12/png.h =================================================================== --- libpng-1.2.12/png.h (révision 54) +++ libpng-1.2.12/png.h (copie de travail) @@ -900,6 +900,16 @@ png_fixed_point int_y_blue; #endif +#if defined(PNG_APNG_SUPPORTED) + png_uint_32 num_frames; + png_uint_32 num_iterations; + png_uint_32 next_frame_x_offset; + png_uint_32 next_frame_y_offset; + png_uint_16 next_frame_delay_num; + png_uint_16 next_frame_delay_den; + png_byte next_frame_render_op; +#endif + } png_info; typedef png_info FAR * png_infop; @@ -1001,6 +1011,8 @@ #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 /* This is used for the transformation routines, as some of them * change these values for the row. It also should enable using @@ -1041,7 +1053,10 @@ typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, png_uint_32, int)); +#if defined(PNG_APNG_SUPPORTED) +typedef void (PNGAPI *png_progressive_frame_ptr) PNGARG((png_structp, png_uint_32)); #endif +#endif #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ @@ -1367,8 +1382,33 @@ png_uint_32 user_height_max; #endif +#if defined(PNG_APNG_SUPPORTED) + png_uint_32 apng_flags; + png_uint_32 num_frames_expected; /* to read or write, according to acTL */ +#endif + +#if defined(PNG_READ_APNG_SUPPORTED) + png_uint_32 num_frames_read; /* incremented after all image data of */ + /* a frame is read */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED + png_progressive_frame_ptr frame_fn; /* frame read callback */ +#endif +#endif + +#if defined(PNG_WRITE_APNG_SUPPORTED) + png_uint_32 num_frames_written; /* only used when writing APNGs */ + png_uint_32 fdAT_length; /* fdAT chunk length */ + png_uint_32 fdAT_crc; +#endif + }; +/* png_struct.apng_flags: */ +/* only count the size of IDATs, don't write them */ +#define PNG_DO_NOT_WRITE_IDAT 0x0001 +#define PNG_DO_fdAT_CRC 0x0002 +/* used for progressive reading */ +#define PNG_INSIDE_fdAT 0x0004 /* This triggers a compiler error in png.c, if png.c and png.h * do not agree upon the version number. @@ -1688,6 +1728,16 @@ extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, png_bytepp image)); +#if defined(PNG_WRITE_APNG_SUPPORTED) +extern PNG_EXPORT (void,png_write_frame_head) PNGARG((png_structp png_ptr, + png_infop png_info, png_bytepp row_pointers, + 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_write_frame_tail) PNGARG((png_structp png_ptr, + png_infop png_info)); +#endif + /* writes the end of the PNG file. */ extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, png_infop info_ptr)); @@ -1936,6 +1986,10 @@ png_voidp progressive_ptr, png_progressive_info_ptr info_fn, png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn)); +#if defined(PNG_READ_APNG_SUPPORTED) +extern PNG_EXPORT(void,png_set_progressive_frame_fn) PNGARG((png_structp png_ptr, + png_progressive_frame_ptr frame_fn)); +#endif /* returns the user pointer associated with the push read functions */ extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) @@ -2364,6 +2418,44 @@ #endif #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, + 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, + 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) + PNGARG((png_structp png_ptr, png_infop info_ptr, 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) + PNGARG((png_structp png_ptr, png_infop info_ptr, 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_get_next_frame_x_offset) + PNGARG((png_structp png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32,png_get_next_frame_y_offset) + PNGARG((png_structp png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_16,png_get_next_frame_delay_num) + PNGARG((png_structp png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_16,png_get_next_frame_delay_den) + PNGARG((png_structp png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_byte,png_get_next_frame_render_op) + PNGARG((png_structp png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_byte,png_next_frame_is_hidden) + PNGARG((png_structp png_ptr, png_infop info_ptr)); +#endif /* PNG_APNG_SUPPORTED */ + +#if defined(PNG_READ_APNG_SUPPORTED) +extern PNG_EXPORT(void,png_read_frame_head) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) /* provide a list of chunks and how they are to be handled, if the built-in handling or default unknown chunk handling is not desired. Any chunks not @@ -2667,6 +2759,8 @@ #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 /* flags for the transformations the PNG library does on the image data */ #define PNG_BGR 0x0001 @@ -2810,6 +2904,10 @@ #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, 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'} +#define PNG_feND const png_byte png_feND[5] = {102, 101, 78, 68, '\0'} #ifdef PNG_USE_GLOBAL_ARRAYS PNG_EXPORT_VAR (const png_byte FARDATA) png_IHDR[5]; @@ -2833,6 +2931,10 @@ 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_feND[5]; #endif /* PNG_USE_GLOBAL_ARRAYS */ #if defined(PNG_1_0_X) || defined (PNG_1_2_X) @@ -3107,6 +3209,15 @@ #endif #endif +#if defined(PNG_WRITE_APNG_SUPPORTED) +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_uint_32 x_offset, png_uint_32 y_offset, png_uint_16 delay_num, + png_uint_16 delay_den, png_byte render_op)); +#endif + /* Called when finished processing a row of data */ PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); @@ -3158,6 +3269,16 @@ PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, png_infop info_ptr)); +#if defined(PNG_READ_APNG_SUPPORTED) +/* private, reset some things to become ready for reading next frame */ +PNG_EXTERN void png_read_reset PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_progressive_read_reset PNGARG((png_structp png_ptr)); +#endif +#if defined(PNG_WRITE_APNG_SUPPORTED) +/* private, reset some things to become ready for writing next frame */ +PNG_EXTERN void png_write_reset PNGARG((png_structp png_ptr)); +#endif + /* these are the functions that do the transformations */ #if defined(PNG_READ_FILLER_SUPPORTED) PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, @@ -3373,6 +3494,17 @@ png_uint_32 length)); #endif +#if defined(PNG_READ_APNG_SUPPORTED) +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_uint_32 length)); +PNG_EXTERN void png_handle_fdAT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_feND PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, png_infop info_ptr, png_uint_32 length)); Index: libpng-1.2.12/pngconf.h =================================================================== --- libpng-1.2.12/pngconf.h (révision 54) +++ libpng-1.2.12/pngconf.h (copie de travail) @@ -894,6 +894,10 @@ # define PNG_READ_zTXt_SUPPORTED # define PNG_zTXt_SUPPORTED #endif +#ifndef PNG_NO_READ_APNG +# define PNG_READ_APNG_SUPPORTED +# define PNG_APNG_SUPPORTED +#endif #ifndef PNG_NO_READ_UNKNOWN_CHUNKS # define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED # ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED @@ -1036,6 +1040,12 @@ # define PNG_zTXt_SUPPORTED # endif #endif +#ifndef PNG_NO_WRITE_APNG +# define PNG_WRITE_APNG_SUPPORTED +# ifndef PNG_APNG_SUPPORTED +# define PNG_APNG_SUPPORTED +# endif +#endif #ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS # define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED # ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED Index: libpng-1.2.12/pngwrite.c =================================================================== --- libpng-1.2.12/pngwrite.c (révision 54) +++ libpng-1.2.12/pngwrite.c (copie de travail) @@ -261,6 +261,25 @@ } } #endif +#if defined(PNG_WRITE_APNG_SUPPORTED) + if (info_ptr->valid & PNG_INFO_acTL) + { + if (!(info_ptr->valid & PNG_INFO_fcTL)) + png_error(png_ptr, "Unable to write acTL when fcTL not set"); + png_write_acTL(png_ptr, info_ptr->num_frames, info_ptr->num_iterations); + } + if (info_ptr->valid & PNG_INFO_fcTL) + { + if (!(info_ptr->valid & PNG_INFO_acTL)) + png_error(png_ptr, "Unable to write fcTL when acTL not set"); + png_write_fcTL(png_ptr, + info_ptr->next_frame_x_offset, + info_ptr->next_frame_y_offset, + info_ptr->next_frame_delay_num, + info_ptr->next_frame_delay_den, + info_ptr->next_frame_render_op); + } +#endif #if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED) if (info_ptr->unknown_chunks_num) { @@ -299,6 +318,10 @@ return; if (!(png_ptr->mode & PNG_HAVE_IDAT)) png_error(png_ptr, "No IDATs written into file"); +#if defined(PNG_WRITE_APNG_SUPPORTED) + if (png_ptr->num_frames_expected != png_ptr->num_frames_written) + png_error(png_ptr, "Not enough frames written"); +#endif /* see if user wants us to write information chunks */ if (info_ptr != NULL) @@ -1510,4 +1533,89 @@ /* quiet compiler warnings */ return; } #endif + +#if defined(PNG_WRITE_APNG_SUPPORTED) +void PNGAPI +png_write_frame_head(png_structp png_ptr, png_infop info_ptr, + png_bytepp row_pointers, 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_fdAT; +#endif + png_byte prepared_length[4]; + png_byte data[17]; + + png_debug(1, "in png_write_frame_head\n"); + + /* there is a chance these have been set after png_write_info was called, + * so they 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_fcTL)) + png_error(png_ptr, "png_write_frame_head(): fcTL not set"); + + /* do nothing for the regular IDAT */ + if(png_ptr->num_frames_written == 0) + return; + + /* figure out the fdAT data length */ + png_ptr->fdAT_length = 41; /* fcTL + feND */ + png_write_reset(png_ptr); + png_ptr->apng_flags |= PNG_DO_NOT_WRITE_IDAT; + png_write_image(png_ptr, row_pointers); + png_ptr->apng_flags &= ~PNG_DO_NOT_WRITE_IDAT; + png_write_reset(png_ptr); + + png_ptr->apng_flags |= PNG_DO_fdAT_CRC; + png_ptr->fdAT_crc = crc32(0, Z_NULL, 0); + + png_save_uint_32(prepared_length, png_ptr->fdAT_length); + png_write_data(png_ptr, prepared_length, 4); + + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, (png_bytep)png_fdAT, 4); + png_write_data(png_ptr, (png_bytep)png_fdAT, 4); + + png_write_fcTL(png_ptr, x_offset, y_offset, + delay_num, delay_den, render_op); +} + +void PNGAPI +png_write_frame_tail(png_structp png_ptr, png_infop png_info) +{ +#ifdef PNG_USE_LOCAL_ARRAYS + PNG_feND; +#endif + png_byte buf[4]; + + png_debug(1, "in png_write_frame_tail\n"); + + png_ptr->num_frames_written++; + + /* do nothing else for the regular IDAT */ + if(png_ptr->num_frames_written == 1) + return; + + /* write feND chunk */ + /* chunk length */ + buf[0] = buf[1] = buf[2] = buf[3] = 0; + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, buf, 4); + png_write_data(png_ptr, buf, 4); + /* chunk name */ + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, png_feND, 4); + png_calculate_crc(png_ptr, (png_bytep)png_feND, 4); + png_write_data(png_ptr, (png_bytep)png_feND, 4); + /* chunk crc */ + png_save_uint_32(buf, png_ptr->crc); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, buf, 4); + png_write_data(png_ptr, buf, 4); + + /* write the fdAT crc */ + png_save_uint_32(buf, png_ptr->fdAT_crc); + png_write_data(png_ptr, buf, (png_size_t)4); + + /* don't need to unset PNG_DO_ADAT_CRC in png_ptr->apng_flags */ +} +#endif /* PNG_WRITE_APNG_SUPPORTED */ + #endif /* PNG_WRITE_SUPPORTED */ Index: libpng-1.2.12/pngset.c =================================================================== --- libpng-1.2.12/pngset.c (révision 54) +++ libpng-1.2.12/pngset.c (copie de travail) @@ -362,6 +362,11 @@ info_ptr->rowbytes = (png_size_t)0; else 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 */ + info_ptr->num_frames = 1; +#endif } #if defined(PNG_oFFs_SUPPORTED) @@ -993,6 +998,91 @@ } #endif /* PNG_sPLT_SUPPORTED */ +#if defined(PNG_APNG_SUPPORTED) +png_uint_32 PNGAPI +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"); + + if (png_ptr == NULL || info_ptr == NULL) + { + png_warning(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"); + return (0); + } + if(num_frames > PNG_UINT_31_MAX) + { + png_warning(png_ptr, + "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 " + "> 2^31-1"); + return (0); + } + + info_ptr->num_frames = num_frames; + info_ptr->num_iterations = num_iterations; + + 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_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"); + + if (png_ptr == NULL || info_ptr == NULL) + { + png_warning(png_ptr, + "Call to png_set_fcTL() with NULL png_ptr or info_ptr " + "ignored"); + return (0); + } + if (render_op & 0xE0) + { + /* Bits 5 through 7 are reserved and must be set to zero (APNG spec) */ + png_warning(png_ptr, + "Ignoring attempt to set fcTL with invalid render_op"); + return (0); + } + //!!?? some more error-checking on render_op's displose bits + if (x_offset > PNG_UINT_31_MAX || y_offset > PNG_UINT_31_MAX) + { + png_warning(png_ptr, + "Ignoring attempt to set fcTL with x_offset or y_offset " + "> 2^31-1"); + return (0); + } + info_ptr->next_frame_x_offset = x_offset; + info_ptr->next_frame_y_offset = y_offset; + info_ptr->next_frame_delay_num = delay_num; + info_ptr->next_frame_delay_den = delay_den; + info_ptr->next_frame_render_op = render_op; + + info_ptr->valid |= PNG_INFO_fcTL; + + return (1); +} +#endif /* PNG_APNG_SUPPORTED */ + #if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) void PNGAPI png_set_unknown_chunks(png_structp png_ptr, Index: libpng-1.2.12/pngwutil.c =================================================================== --- libpng-1.2.12/pngwutil.c (révision 54) +++ libpng-1.2.12/pngwutil.c (copie de travail) @@ -605,6 +605,15 @@ #endif png_debug(1, "in png_write_IDAT\n"); +#if defined(PNG_WRITE_APNG_SUPPORTED) + if (png_ptr->apng_flags & PNG_DO_NOT_WRITE_IDAT) + { + /* only record the size of the data that would be written */ + png_ptr->fdAT_length += length + 12; + return; + } +#endif + /* Optimize the CMF field in the zlib stream. */ /* This hack of the zlib stream is compliant to the stream specification. */ if (!(png_ptr->mode & PNG_HAVE_IDAT) && @@ -646,6 +655,20 @@ png_write_chunk(png_ptr, (png_bytep)png_IDAT, data, length); png_ptr->mode |= PNG_HAVE_IDAT; + +#if defined(PNG_WRITE_APNG_SUPPORTED) + if (png_ptr->apng_flags & PNG_DO_fdAT_CRC) + { + png_byte buf[4]; + png_save_uint_32(buf, length); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, buf, 4); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, (png_bytep)png_IDAT, 4); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, data, length); + /* png_ptr->crc now holds crc on the IDAT just written */ + png_save_uint_32(buf, png_ptr->crc); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, buf, 4); + } +#endif } /* write an IEND chunk */ @@ -1693,6 +1716,79 @@ } #endif +#if defined(PNG_WRITE_APNG_SUPPORTED) +void /* PRIVATE */ +png_write_acTL(png_structp png_ptr, + png_uint_32 num_frames, png_uint_32 num_iterations) +{ +#ifdef PNG_USE_LOCAL_ARRAYS + PNG_acTL; +#endif + png_byte data[8]; + + png_debug(1, "in png_write_acTL\n"); + + if (num_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 " + "(> 2^31-1)"); + if (num_iterations > PNG_UINT_31_MAX) + png_error(png_ptr, "png_write_acTL: invalid number of iterations " + "(> 2^31-1)"); + + png_ptr->num_frames_expected = num_frames; + + png_save_uint_32(data, num_frames); + png_save_uint_32(data + 4, num_iterations); + + 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 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; +#endif + png_byte data[17]; + png_byte buf[4]; + + png_debug(1, "in png_write_fcTL\n"); + + if (render_op & 0xE0) + /* Bits 5 through 7 are reserved and must be set to zero (APNG spec) */ + png_error(png_ptr, "png_write_fcTL: invalid render_op"); + //!!?? some more error-checking on render_op's displose bits + if (png_ptr->num_frames_written == 0 && (x_offset != 0 || y_offset != 0)) + png_error(png_ptr, + "png_write_fcTL: fcTL for the first frame with " + "non-zero x_offset or y_offset not allowed"); + if (x_offset > PNG_UINT_31_MAX) + png_error(png_ptr, "png_write_fcTL: invalid x_offset (> 2^31-1)"); + if (y_offset > PNG_UINT_31_MAX) + png_error(png_ptr, "png_write_fcTL: invalid y_offset (> 2^31-1)"); + + png_save_uint_32(buf, 17); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, buf, 4); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, png_fcTL, 4); + + png_save_uint_32(data, png_ptr->num_frames_written); + png_save_uint_32(data + 4, x_offset); + png_save_uint_32(data + 8, y_offset); + png_save_uint_16(data + 12, delay_num); + png_save_uint_16(data + 14, delay_den); + data[16] = render_op; + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, data, 17); + + png_write_chunk(png_ptr, (png_bytep)png_fcTL, data, (png_size_t)17); + + png_save_uint_32(buf, png_ptr->crc); + png_ptr->fdAT_crc = crc32(png_ptr->fdAT_crc, buf, 4); +} +#endif /* PNG_WRITE_APNG_SUPPORTED */ + /* initializes the row writing capability of libpng */ void /* PRIVATE */ png_write_start_row(png_structp png_ptr) @@ -1720,14 +1816,16 @@ 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, (png_uint_32)buf_size); + if (png_ptr->row_buf == NULL) + png_ptr->row_buf = (png_bytep)png_malloc(png_ptr, (png_uint_32)buf_size); png_ptr->row_buf[0] = PNG_FILTER_VALUE_NONE; /* 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)); + if (png_ptr->sub_row == NULL) + png_ptr->sub_row = (png_bytep)png_malloc(png_ptr, + (png_ptr->rowbytes + 1)); png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB; } @@ -1735,27 +1833,31 @@ 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, (png_uint_32)buf_size); + if (png_ptr->prev_row == NULL) + png_ptr->prev_row = (png_bytep)png_malloc(png_ptr, (png_uint_32)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)); + if (png_ptr->up_row == NULL) + png_ptr->up_row = (png_bytep )png_malloc(png_ptr, + (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)); + if (png_ptr->avg_row == NULL) + png_ptr->avg_row = (png_bytep)png_malloc(png_ptr, + (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)); + if (png_ptr->paeth_row == NULL) + png_ptr->paeth_row = (png_bytep )png_malloc(png_ptr, + (png_ptr->rowbytes + 1)); png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH; } } @@ -2747,4 +2849,13 @@ } #endif } + +#if defined(PNG_WRITE_APNG_SUPPORTED) +void PNGAPI +png_write_reset(png_structp png_ptr) +{ + png_ptr->row_number = 0; + png_ptr->pass = 0; +} +#endif #endif /* PNG_WRITE_SUPPORTED */