2 /* pngrutil.c - utilities to read a PNG file
4 * Last changed in libpng 1.5.14 [January 24, 2013]
5 * Copyright (c) 1998-2013 Glenn Randers-Pehrson
6 * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
7 * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
9 * This code is released under the libpng license.
10 * For conditions of distribution and use, see the disclaimer
11 * and license in png.h
13 * This file contains routines that are only called from within
14 * libpng itself during the course of reading an image.
19 #ifdef PNG_READ_SUPPORTED
21 #define png_strtod(p,a,b) strtod(a,b)
24 png_get_uint_31(png_structp png_ptr
, png_const_bytep buf
)
26 png_uint_32 uval
= png_get_uint_32(buf
);
28 if (uval
> PNG_UINT_31_MAX
)
29 png_error(png_ptr
, "PNG unsigned integer out of range");
34 #if defined(PNG_READ_gAMA_SUPPORTED) || defined(PNG_READ_cHRM_SUPPORTED)
35 /* The following is a variation on the above for use with the fixed
36 * point values used for gAMA and cHRM. Instead of png_error it
37 * issues a warning and returns (-1) - an invalid value because both
38 * gAMA and cHRM use *unsigned* integers for fixed point values.
40 #define PNG_FIXED_ERROR (-1)
42 static png_fixed_point
/* PRIVATE */
43 png_get_fixed_point(png_structp png_ptr
, png_const_bytep buf
)
45 png_uint_32 uval
= png_get_uint_32(buf
);
47 if (uval
<= PNG_UINT_31_MAX
)
48 return (png_fixed_point
)uval
; /* known to be in range */
50 /* The caller can turn off the warning by passing NULL. */
52 png_warning(png_ptr
, "PNG fixed point integer out of range");
54 return PNG_FIXED_ERROR
;
58 #ifdef PNG_READ_INT_FUNCTIONS_SUPPORTED
59 /* NOTE: the read macros will obscure these definitions, so that if
60 * PNG_USE_READ_MACROS is set the library will not use them internally,
61 * but the APIs will still be available externally.
63 * The parentheses around "PNGAPI function_name" in the following three
64 * functions are necessary because they allow the macros to co-exist with
65 * these (unused but exported) functions.
68 /* Grab an unsigned 32-bit integer from a buffer in big-endian format. */
70 png_get_uint_32
)(png_const_bytep buf
)
73 ((png_uint_32
)(*(buf
)) << 24) +
74 ((png_uint_32
)(*(buf
+ 1)) << 16) +
75 ((png_uint_32
)(*(buf
+ 2)) << 8) +
76 ((png_uint_32
)(*(buf
+ 3)) ) ;
81 /* Grab a signed 32-bit integer from a buffer in big-endian format. The
82 * data is stored in the PNG file in two's complement format and there
83 * is no guarantee that a 'png_int_32' is exactly 32 bits, therefore
84 * the following code does a two's complement to native conversion.
87 png_get_int_32
)(png_const_bytep buf
)
89 png_uint_32 uval
= png_get_uint_32(buf
);
90 if ((uval
& 0x80000000) == 0) /* non-negative */
93 uval
= (uval
^ 0xffffffff) + 1; /* 2's complement: -x = ~x+1 */
94 return -(png_int_32
)uval
;
97 /* Grab an unsigned 16-bit integer from a buffer in big-endian format. */
99 png_get_uint_16
)(png_const_bytep buf
)
101 /* ANSI-C requires an int value to accomodate at least 16 bits so this
102 * works and allows the compiler not to worry about possible narrowing
103 * on 32 bit systems. (Pre-ANSI systems did not make integers smaller
104 * than 16 bits either.)
107 ((unsigned int)(*buf
) << 8) +
108 ((unsigned int)(*(buf
+ 1)));
110 return (png_uint_16
)val
;
113 #endif /* PNG_READ_INT_FUNCTIONS_SUPPORTED */
115 /* Read and check the PNG file signature */
117 png_read_sig(png_structp png_ptr
, png_infop info_ptr
)
119 png_size_t num_checked
, num_to_check
;
121 /* Exit if the user application does not expect a signature. */
122 if (png_ptr
->sig_bytes
>= 8)
125 num_checked
= png_ptr
->sig_bytes
;
126 num_to_check
= 8 - num_checked
;
128 #ifdef PNG_IO_STATE_SUPPORTED
129 png_ptr
->io_state
= PNG_IO_READING
| PNG_IO_SIGNATURE
;
132 /* The signature must be serialized in a single I/O call. */
133 png_read_data(png_ptr
, &(info_ptr
->signature
[num_checked
]), num_to_check
);
134 png_ptr
->sig_bytes
= 8;
136 if (png_sig_cmp(info_ptr
->signature
, num_checked
, num_to_check
))
138 if (num_checked
< 4 &&
139 png_sig_cmp(info_ptr
->signature
, num_checked
, num_to_check
- 4))
140 png_error(png_ptr
, "Not a PNG file");
142 png_error(png_ptr
, "PNG file corrupted by ASCII conversion");
145 png_ptr
->mode
|= PNG_HAVE_PNG_SIGNATURE
;
148 /* Read the chunk header (length + type name).
149 * Put the type name into png_ptr->chunk_name, and return the length.
151 png_uint_32
/* PRIVATE */
152 png_read_chunk_header(png_structp png_ptr
)
157 #ifdef PNG_IO_STATE_SUPPORTED
158 png_ptr
->io_state
= PNG_IO_READING
| PNG_IO_CHUNK_HDR
;
161 /* Read the length and the chunk name.
162 * This must be performed in a single I/O call.
164 png_read_data(png_ptr
, buf
, 8);
165 length
= png_get_uint_31(png_ptr
, buf
);
167 /* Put the chunk name into png_ptr->chunk_name. */
168 png_ptr
->chunk_name
= PNG_CHUNK_FROM_STRING(buf
+4);
170 png_debug2(0, "Reading %lx chunk, length = %lu",
171 (unsigned long)png_ptr
->chunk_name
, (unsigned long)length
);
173 /* Reset the crc and run it over the chunk name. */
174 png_reset_crc(png_ptr
);
175 png_calculate_crc(png_ptr
, buf
+ 4, 4);
177 /* Check to see if chunk name is valid. */
178 png_check_chunk_name(png_ptr
, png_ptr
->chunk_name
);
180 #ifdef PNG_IO_STATE_SUPPORTED
181 png_ptr
->io_state
= PNG_IO_READING
| PNG_IO_CHUNK_DATA
;
187 /* Read data, and (optionally) run it through the CRC. */
189 png_crc_read(png_structp png_ptr
, png_bytep buf
, png_size_t length
)
194 png_read_data(png_ptr
, buf
, length
);
195 png_calculate_crc(png_ptr
, buf
, length
);
198 /* Optionally skip data and then check the CRC. Depending on whether we
199 * are reading a ancillary or critical chunk, and how the program has set
200 * things up, we may calculate the CRC on the data and print a message.
201 * Returns '1' if there was a CRC error, '0' otherwise.
204 png_crc_finish(png_structp png_ptr
, png_uint_32 skip
)
207 png_size_t istop
= png_ptr
->zbuf_size
;
209 for (i
= (png_size_t
)skip
; i
> istop
; i
-= istop
)
211 png_crc_read(png_ptr
, png_ptr
->zbuf
, png_ptr
->zbuf_size
);
216 png_crc_read(png_ptr
, png_ptr
->zbuf
, i
);
219 if (png_crc_error(png_ptr
))
221 if (PNG_CHUNK_ANCILLIARY(png_ptr
->chunk_name
) ?
222 !(png_ptr
->flags
& PNG_FLAG_CRC_ANCILLARY_NOWARN
) :
223 (png_ptr
->flags
& PNG_FLAG_CRC_CRITICAL_USE
))
225 png_chunk_warning(png_ptr
, "CRC error");
230 png_chunk_benign_error(png_ptr
, "CRC error");
240 /* Compare the CRC stored in the PNG file with that calculated by libpng from
241 * the data it has read thus far.
244 png_crc_error(png_structp png_ptr
)
246 png_byte crc_bytes
[4];
250 if (PNG_CHUNK_ANCILLIARY(png_ptr
->chunk_name
))
252 if ((png_ptr
->flags
& PNG_FLAG_CRC_ANCILLARY_MASK
) ==
253 (PNG_FLAG_CRC_ANCILLARY_USE
| PNG_FLAG_CRC_ANCILLARY_NOWARN
))
259 if (png_ptr
->flags
& PNG_FLAG_CRC_CRITICAL_IGNORE
)
263 #ifdef PNG_IO_STATE_SUPPORTED
264 png_ptr
->io_state
= PNG_IO_READING
| PNG_IO_CHUNK_CRC
;
267 /* The chunk CRC must be serialized in a single I/O call. */
268 png_read_data(png_ptr
, crc_bytes
, 4);
272 crc
= png_get_uint_32(crc_bytes
);
273 return ((int)(crc
!= png_ptr
->crc
));
280 #ifdef PNG_READ_COMPRESSED_TEXT_SUPPORTED
282 png_inflate(png_structp png_ptr
, png_bytep data
, png_size_t size
,
283 png_bytep output
, png_size_t output_size
)
285 png_size_t count
= 0;
287 /* zlib can't necessarily handle more than 65535 bytes at once (i.e. it can't
288 * even necessarily handle 65536 bytes) because the type uInt is "16 bits or
289 * more". Consequently it is necessary to chunk the input to zlib. This
290 * code uses ZLIB_IO_MAX, from pngpriv.h, as the maximum (the maximum value
291 * that can be stored in a uInt.) It is possible to set ZLIB_IO_MAX to a
292 * lower value in pngpriv.h and this may sometimes have a performance
293 * advantage, because it forces access of the input data to be separated from
294 * at least some of the use by some period of time.
296 png_ptr
->zstream
.next_in
= data
;
297 /* avail_in is set below from 'size' */
298 png_ptr
->zstream
.avail_in
= 0;
304 /* The setting of 'avail_in' used to be outside the loop; by setting it
305 * inside it is possible to chunk the input to zlib and simply rely on
306 * zlib to advance the 'next_in' pointer. This allows arbitrary amounts o
307 * data to be passed through zlib at the unavoidable cost of requiring a
308 * window save (memcpy of up to 32768 output bytes) every ZLIB_IO_MAX
311 if (png_ptr
->zstream
.avail_in
== 0 && size
> 0)
313 if (size
<= ZLIB_IO_MAX
)
315 /* The value is less than ZLIB_IO_MAX so the cast is safe: */
316 png_ptr
->zstream
.avail_in
= (uInt
)size
;
322 png_ptr
->zstream
.avail_in
= ZLIB_IO_MAX
;
327 /* Reset the output buffer each time round - we empty it
328 * after every inflate call.
330 png_ptr
->zstream
.next_out
= png_ptr
->zbuf
;
331 png_ptr
->zstream
.avail_out
= png_ptr
->zbuf_size
;
333 ret
= inflate(&png_ptr
->zstream
, Z_NO_FLUSH
);
334 avail
= png_ptr
->zbuf_size
- png_ptr
->zstream
.avail_out
;
336 /* First copy/count any new output - but only if we didn't
339 if ((ret
== Z_OK
|| ret
== Z_STREAM_END
) && avail
> 0)
341 png_size_t space
= avail
; /* > 0, see above */
343 if (output
!= 0 && output_size
> count
)
345 png_size_t copy
= output_size
- count
;
350 png_memcpy(output
+ count
, png_ptr
->zbuf
, copy
);
358 /* Termination conditions - always reset the zstream, it
359 * must be left in inflateInit state.
361 png_ptr
->zstream
.avail_in
= 0;
362 inflateReset(&png_ptr
->zstream
);
364 if (ret
== Z_STREAM_END
)
365 return count
; /* NOTE: may be zero. */
367 /* Now handle the error codes - the API always returns 0
368 * and the error message is dumped into the uncompressed
369 * buffer if available.
371 # ifdef PNG_WARNINGS_SUPPORTED
375 if (png_ptr
->zstream
.msg
!= 0)
376 msg
= png_ptr
->zstream
.msg
;
381 msg
= "Buffer error in compressed datastream";
385 msg
= "Data error in compressed datastream";
389 msg
= "Incomplete compressed datastream";
393 png_chunk_warning(png_ptr
, msg
);
397 /* 0 means an error - notice that this code simply ignores
398 * zero length compressed chunks as a result.
405 * Decompress trailing data in a chunk. The assumption is that chunkdata
406 * points at an allocated area holding the contents of a chunk with a
407 * trailing compressed part. What we get back is an allocated area
408 * holding the original prefix part and an uncompressed version of the
409 * trailing part (the malloc area passed in is freed).
412 png_decompress_chunk(png_structp png_ptr
, int comp_type
,
413 png_size_t chunklength
,
414 png_size_t prefix_size
, png_size_t
*newlength
)
416 /* The caller should guarantee this */
417 if (prefix_size
> chunklength
)
419 /* The recovery is to delete the chunk. */
420 png_warning(png_ptr
, "invalid chunklength");
421 prefix_size
= 0; /* To delete everything */
424 else if (comp_type
== PNG_COMPRESSION_TYPE_BASE
)
426 png_size_t expanded_size
= png_inflate(png_ptr
,
427 (png_bytep
)(png_ptr
->chunkdata
+ prefix_size
),
428 chunklength
- prefix_size
,
430 0); /* output size */
432 /* Now check the limits on this chunk - if the limit fails the
433 * compressed data will be removed, the prefix will remain.
435 if (prefix_size
>= (~(png_size_t
)0) - 1 ||
436 expanded_size
>= (~(png_size_t
)0) - 1 - prefix_size
437 #ifdef PNG_USER_LIMITS_SUPPORTED
438 || (png_ptr
->user_chunk_malloc_max
&&
439 (prefix_size
+ expanded_size
>= png_ptr
->user_chunk_malloc_max
- 1))
441 || ((PNG_USER_CHUNK_MALLOC_MAX
> 0) &&
442 prefix_size
+ expanded_size
>= PNG_USER_CHUNK_MALLOC_MAX
- 1)
445 png_warning(png_ptr
, "Exceeded size limit while expanding chunk");
447 /* If the size is zero either there was an error and a message
448 * has already been output (warning) or the size really is zero
449 * and we have nothing to do - the code will exit through the
452 else if (expanded_size
> 0)
454 /* Success (maybe) - really uncompress the chunk. */
455 png_size_t new_size
= 0;
456 png_charp text
= (png_charp
)png_malloc_warn(png_ptr
,
457 prefix_size
+ expanded_size
+ 1);
461 png_memcpy(text
, png_ptr
->chunkdata
, prefix_size
);
462 new_size
= png_inflate(png_ptr
,
463 (png_bytep
)(png_ptr
->chunkdata
+ prefix_size
),
464 chunklength
- prefix_size
,
465 (png_bytep
)(text
+ prefix_size
), expanded_size
);
466 text
[prefix_size
+ expanded_size
] = 0; /* just in case */
468 if (new_size
== expanded_size
)
470 png_free(png_ptr
, png_ptr
->chunkdata
);
471 png_ptr
->chunkdata
= text
;
472 *newlength
= prefix_size
+ expanded_size
;
473 return; /* The success return! */
476 png_warning(png_ptr
, "png_inflate logic error");
477 png_free(png_ptr
, text
);
481 png_warning(png_ptr
, "Not enough memory to decompress chunk");
485 else /* if (comp_type != PNG_COMPRESSION_TYPE_BASE) */
487 PNG_WARNING_PARAMETERS(p
)
488 png_warning_parameter_signed(p
, 1, PNG_NUMBER_FORMAT_d
, comp_type
);
489 png_formatted_warning(png_ptr
, p
, "Unknown compression type @1");
491 /* The recovery is to simply drop the data. */
494 /* Generic error return - leave the prefix, delete the compressed
495 * data, reallocate the chunkdata to remove the potentially large
496 * amount of compressed data.
499 png_charp text
= (png_charp
)png_malloc_warn(png_ptr
, prefix_size
+ 1);
504 png_memcpy(text
, png_ptr
->chunkdata
, prefix_size
);
506 png_free(png_ptr
, png_ptr
->chunkdata
);
507 png_ptr
->chunkdata
= text
;
509 /* This is an extra zero in the 'uncompressed' part. */
510 *(png_ptr
->chunkdata
+ prefix_size
) = 0x00;
512 /* Ignore a malloc error here - it is safe. */
515 *newlength
= prefix_size
;
517 #endif /* PNG_READ_COMPRESSED_TEXT_SUPPORTED */
519 /* Read and check the IDHR chunk */
521 png_handle_IHDR(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
524 png_uint_32 width
, height
;
525 int bit_depth
, color_type
, compression_type
, filter_type
;
528 png_debug(1, "in png_handle_IHDR");
530 if (png_ptr
->mode
& PNG_HAVE_IHDR
)
531 png_error(png_ptr
, "Out of place IHDR");
533 /* Check the length */
535 png_error(png_ptr
, "Invalid IHDR chunk");
537 png_ptr
->mode
|= PNG_HAVE_IHDR
;
539 png_crc_read(png_ptr
, buf
, 13);
540 png_crc_finish(png_ptr
, 0);
542 width
= png_get_uint_31(png_ptr
, buf
);
543 height
= png_get_uint_31(png_ptr
, buf
+ 4);
546 compression_type
= buf
[10];
547 filter_type
= buf
[11];
548 interlace_type
= buf
[12];
550 /* Set internal variables */
551 png_ptr
->width
= width
;
552 png_ptr
->height
= height
;
553 png_ptr
->bit_depth
= (png_byte
)bit_depth
;
554 png_ptr
->interlaced
= (png_byte
)interlace_type
;
555 png_ptr
->color_type
= (png_byte
)color_type
;
556 #ifdef PNG_MNG_FEATURES_SUPPORTED
557 png_ptr
->filter_type
= (png_byte
)filter_type
;
559 png_ptr
->compression_type
= (png_byte
)compression_type
;
561 /* Find number of channels */
562 switch (png_ptr
->color_type
)
564 default: /* invalid, png_set_IHDR calls png_error */
565 case PNG_COLOR_TYPE_GRAY
:
566 case PNG_COLOR_TYPE_PALETTE
:
567 png_ptr
->channels
= 1;
570 case PNG_COLOR_TYPE_RGB
:
571 png_ptr
->channels
= 3;
574 case PNG_COLOR_TYPE_GRAY_ALPHA
:
575 png_ptr
->channels
= 2;
578 case PNG_COLOR_TYPE_RGB_ALPHA
:
579 png_ptr
->channels
= 4;
583 /* Set up other useful info */
584 png_ptr
->pixel_depth
= (png_byte
)(png_ptr
->bit_depth
*
586 png_ptr
->rowbytes
= PNG_ROWBYTES(png_ptr
->pixel_depth
, png_ptr
->width
);
587 png_debug1(3, "bit_depth = %d", png_ptr
->bit_depth
);
588 png_debug1(3, "channels = %d", png_ptr
->channels
);
589 png_debug1(3, "rowbytes = %lu", (unsigned long)png_ptr
->rowbytes
);
590 png_set_IHDR(png_ptr
, info_ptr
, width
, height
, bit_depth
,
591 color_type
, interlace_type
, compression_type
, filter_type
);
594 /* Read and check the palette */
596 png_handle_PLTE(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
598 png_color palette
[PNG_MAX_PALETTE_LENGTH
];
600 #ifdef PNG_POINTER_INDEXING_SUPPORTED
604 png_debug(1, "in png_handle_PLTE");
606 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
607 png_error(png_ptr
, "Missing IHDR before PLTE");
609 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
611 png_warning(png_ptr
, "Invalid PLTE after IDAT");
612 png_crc_finish(png_ptr
, length
);
616 else if (png_ptr
->mode
& PNG_HAVE_PLTE
)
617 png_error(png_ptr
, "Duplicate PLTE chunk");
619 png_ptr
->mode
|= PNG_HAVE_PLTE
;
621 if (!(png_ptr
->color_type
&PNG_COLOR_MASK_COLOR
))
624 "Ignoring PLTE chunk in grayscale PNG");
625 png_crc_finish(png_ptr
, length
);
629 #ifndef PNG_READ_OPT_PLTE_SUPPORTED
630 if (png_ptr
->color_type
!= PNG_COLOR_TYPE_PALETTE
)
632 png_crc_finish(png_ptr
, length
);
637 if (length
> 3*PNG_MAX_PALETTE_LENGTH
|| length
% 3)
639 if (png_ptr
->color_type
!= PNG_COLOR_TYPE_PALETTE
)
641 png_warning(png_ptr
, "Invalid palette chunk");
642 png_crc_finish(png_ptr
, length
);
648 png_error(png_ptr
, "Invalid palette chunk");
652 num
= (int)length
/ 3;
654 #ifdef PNG_POINTER_INDEXING_SUPPORTED
655 for (i
= 0, pal_ptr
= palette
; i
< num
; i
++, pal_ptr
++)
659 png_crc_read(png_ptr
, buf
, 3);
660 pal_ptr
->red
= buf
[0];
661 pal_ptr
->green
= buf
[1];
662 pal_ptr
->blue
= buf
[2];
665 for (i
= 0; i
< num
; i
++)
669 png_crc_read(png_ptr
, buf
, 3);
670 /* Don't depend upon png_color being any order */
671 palette
[i
].red
= buf
[0];
672 palette
[i
].green
= buf
[1];
673 palette
[i
].blue
= buf
[2];
677 /* If we actually need the PLTE chunk (ie for a paletted image), we do
678 * whatever the normal CRC configuration tells us. However, if we
679 * have an RGB image, the PLTE can be considered ancillary, so
680 * we will act as though it is.
682 #ifndef PNG_READ_OPT_PLTE_SUPPORTED
683 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
686 png_crc_finish(png_ptr
, 0);
689 #ifndef PNG_READ_OPT_PLTE_SUPPORTED
690 else if (png_crc_error(png_ptr
)) /* Only if we have a CRC error */
692 /* If we don't want to use the data from an ancillary chunk,
693 * we have two options: an error abort, or a warning and we
694 * ignore the data in this chunk (which should be OK, since
695 * it's considered ancillary for a RGB or RGBA image).
697 if (!(png_ptr
->flags
& PNG_FLAG_CRC_ANCILLARY_USE
))
699 if (png_ptr
->flags
& PNG_FLAG_CRC_ANCILLARY_NOWARN
)
701 png_chunk_benign_error(png_ptr
, "CRC error");
706 png_chunk_warning(png_ptr
, "CRC error");
711 /* Otherwise, we (optionally) emit a warning and use the chunk. */
712 else if (!(png_ptr
->flags
& PNG_FLAG_CRC_ANCILLARY_NOWARN
))
714 png_chunk_warning(png_ptr
, "CRC error");
719 png_set_PLTE(png_ptr
, info_ptr
, palette
, num
);
721 #ifdef PNG_READ_tRNS_SUPPORTED
722 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
724 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_tRNS
))
726 if (png_ptr
->num_trans
> (png_uint_16
)num
)
728 png_warning(png_ptr
, "Truncating incorrect tRNS chunk length");
729 png_ptr
->num_trans
= (png_uint_16
)num
;
732 if (info_ptr
->num_trans
> (png_uint_16
)num
)
734 png_warning(png_ptr
, "Truncating incorrect info tRNS chunk length");
735 info_ptr
->num_trans
= (png_uint_16
)num
;
744 png_handle_IEND(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
746 png_debug(1, "in png_handle_IEND");
748 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
) || !(png_ptr
->mode
& PNG_HAVE_IDAT
))
750 png_error(png_ptr
, "No image in file");
753 png_ptr
->mode
|= (PNG_AFTER_IDAT
| PNG_HAVE_IEND
);
757 png_warning(png_ptr
, "Incorrect IEND chunk length");
760 png_crc_finish(png_ptr
, length
);
762 PNG_UNUSED(info_ptr
) /* Quiet compiler warnings about unused info_ptr */
765 #ifdef PNG_READ_gAMA_SUPPORTED
767 png_handle_gAMA(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
769 png_fixed_point igamma
;
772 png_debug(1, "in png_handle_gAMA");
774 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
775 png_error(png_ptr
, "Missing IHDR before gAMA");
777 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
779 png_warning(png_ptr
, "Invalid gAMA after IDAT");
780 png_crc_finish(png_ptr
, length
);
784 else if (png_ptr
->mode
& PNG_HAVE_PLTE
)
785 /* Should be an error, but we can cope with it */
786 png_warning(png_ptr
, "Out of place gAMA chunk");
788 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_gAMA
)
789 #ifdef PNG_READ_sRGB_SUPPORTED
790 && !(info_ptr
->valid
& PNG_INFO_sRGB
)
794 png_warning(png_ptr
, "Duplicate gAMA chunk");
795 png_crc_finish(png_ptr
, length
);
801 png_warning(png_ptr
, "Incorrect gAMA chunk length");
802 png_crc_finish(png_ptr
, length
);
806 png_crc_read(png_ptr
, buf
, 4);
808 if (png_crc_finish(png_ptr
, 0))
811 igamma
= png_get_fixed_point(NULL
, buf
);
813 /* Check for zero gamma or an error. */
817 "Ignoring gAMA chunk with out of range gamma");
822 # ifdef PNG_READ_sRGB_SUPPORTED
823 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_sRGB
))
825 if (PNG_OUT_OF_RANGE(igamma
, 45500, 500))
827 PNG_WARNING_PARAMETERS(p
)
828 png_warning_parameter_signed(p
, 1, PNG_NUMBER_FORMAT_fixed
, igamma
);
829 png_formatted_warning(png_ptr
, p
,
830 "Ignoring incorrect gAMA value @1 when sRGB is also present");
834 # endif /* PNG_READ_sRGB_SUPPORTED */
836 # ifdef PNG_READ_GAMMA_SUPPORTED
837 /* Gamma correction on read is supported. */
838 png_ptr
->gamma
= igamma
;
840 /* And set the 'info' structure members. */
841 png_set_gAMA_fixed(png_ptr
, info_ptr
, igamma
);
845 #ifdef PNG_READ_sBIT_SUPPORTED
847 png_handle_sBIT(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
852 png_debug(1, "in png_handle_sBIT");
854 buf
[0] = buf
[1] = buf
[2] = buf
[3] = 0;
856 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
857 png_error(png_ptr
, "Missing IHDR before sBIT");
859 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
861 png_warning(png_ptr
, "Invalid sBIT after IDAT");
862 png_crc_finish(png_ptr
, length
);
866 else if (png_ptr
->mode
& PNG_HAVE_PLTE
)
868 /* Should be an error, but we can cope with it */
869 png_warning(png_ptr
, "Out of place sBIT chunk");
872 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_sBIT
))
874 png_warning(png_ptr
, "Duplicate sBIT chunk");
875 png_crc_finish(png_ptr
, length
);
879 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
883 truelen
= (png_size_t
)png_ptr
->channels
;
885 if (length
!= truelen
|| length
> 4)
887 png_warning(png_ptr
, "Incorrect sBIT chunk length");
888 png_crc_finish(png_ptr
, length
);
892 png_crc_read(png_ptr
, buf
, truelen
);
894 if (png_crc_finish(png_ptr
, 0))
897 if (png_ptr
->color_type
& PNG_COLOR_MASK_COLOR
)
899 png_ptr
->sig_bit
.red
= buf
[0];
900 png_ptr
->sig_bit
.green
= buf
[1];
901 png_ptr
->sig_bit
.blue
= buf
[2];
902 png_ptr
->sig_bit
.alpha
= buf
[3];
907 png_ptr
->sig_bit
.gray
= buf
[0];
908 png_ptr
->sig_bit
.red
= buf
[0];
909 png_ptr
->sig_bit
.green
= buf
[0];
910 png_ptr
->sig_bit
.blue
= buf
[0];
911 png_ptr
->sig_bit
.alpha
= buf
[1];
914 png_set_sBIT(png_ptr
, info_ptr
, &(png_ptr
->sig_bit
));
918 #ifdef PNG_READ_cHRM_SUPPORTED
920 png_handle_cHRM(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
923 png_fixed_point x_white
, y_white
, x_red
, y_red
, x_green
, y_green
, x_blue
,
926 png_debug(1, "in png_handle_cHRM");
928 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
929 png_error(png_ptr
, "Missing IHDR before cHRM");
931 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
933 png_warning(png_ptr
, "Invalid cHRM after IDAT");
934 png_crc_finish(png_ptr
, length
);
938 else if (png_ptr
->mode
& PNG_HAVE_PLTE
)
939 /* Should be an error, but we can cope with it */
940 png_warning(png_ptr
, "Out of place cHRM chunk");
942 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_cHRM
)
943 # ifdef PNG_READ_sRGB_SUPPORTED
944 && !(info_ptr
->valid
& PNG_INFO_sRGB
)
948 png_warning(png_ptr
, "Duplicate cHRM chunk");
949 png_crc_finish(png_ptr
, length
);
955 png_warning(png_ptr
, "Incorrect cHRM chunk length");
956 png_crc_finish(png_ptr
, length
);
960 png_crc_read(png_ptr
, buf
, 32);
962 if (png_crc_finish(png_ptr
, 0))
965 x_white
= png_get_fixed_point(NULL
, buf
);
966 y_white
= png_get_fixed_point(NULL
, buf
+ 4);
967 x_red
= png_get_fixed_point(NULL
, buf
+ 8);
968 y_red
= png_get_fixed_point(NULL
, buf
+ 12);
969 x_green
= png_get_fixed_point(NULL
, buf
+ 16);
970 y_green
= png_get_fixed_point(NULL
, buf
+ 20);
971 x_blue
= png_get_fixed_point(NULL
, buf
+ 24);
972 y_blue
= png_get_fixed_point(NULL
, buf
+ 28);
974 if (x_white
== PNG_FIXED_ERROR
||
975 y_white
== PNG_FIXED_ERROR
||
976 x_red
== PNG_FIXED_ERROR
||
977 y_red
== PNG_FIXED_ERROR
||
978 x_green
== PNG_FIXED_ERROR
||
979 y_green
== PNG_FIXED_ERROR
||
980 x_blue
== PNG_FIXED_ERROR
||
981 y_blue
== PNG_FIXED_ERROR
)
983 png_warning(png_ptr
, "Ignoring cHRM chunk with negative chromaticities");
987 #ifdef PNG_READ_sRGB_SUPPORTED
988 if ((info_ptr
!= NULL
) && (info_ptr
->valid
& PNG_INFO_sRGB
))
990 if (PNG_OUT_OF_RANGE(x_white
, 31270, 1000) ||
991 PNG_OUT_OF_RANGE(y_white
, 32900, 1000) ||
992 PNG_OUT_OF_RANGE(x_red
, 64000, 1000) ||
993 PNG_OUT_OF_RANGE(y_red
, 33000, 1000) ||
994 PNG_OUT_OF_RANGE(x_green
, 30000, 1000) ||
995 PNG_OUT_OF_RANGE(y_green
, 60000, 1000) ||
996 PNG_OUT_OF_RANGE(x_blue
, 15000, 1000) ||
997 PNG_OUT_OF_RANGE(y_blue
, 6000, 1000))
999 PNG_WARNING_PARAMETERS(p
)
1001 png_warning_parameter_signed(p
, 1, PNG_NUMBER_FORMAT_fixed
, x_white
);
1002 png_warning_parameter_signed(p
, 2, PNG_NUMBER_FORMAT_fixed
, y_white
);
1003 png_warning_parameter_signed(p
, 3, PNG_NUMBER_FORMAT_fixed
, x_red
);
1004 png_warning_parameter_signed(p
, 4, PNG_NUMBER_FORMAT_fixed
, y_red
);
1005 png_warning_parameter_signed(p
, 5, PNG_NUMBER_FORMAT_fixed
, x_green
);
1006 png_warning_parameter_signed(p
, 6, PNG_NUMBER_FORMAT_fixed
, y_green
);
1007 png_warning_parameter_signed(p
, 7, PNG_NUMBER_FORMAT_fixed
, x_blue
);
1008 png_warning_parameter_signed(p
, 8, PNG_NUMBER_FORMAT_fixed
, y_blue
);
1010 png_formatted_warning(png_ptr
, p
,
1011 "Ignoring incorrect cHRM white(@1,@2) r(@3,@4)g(@5,@6)b(@7,@8) "
1012 "when sRGB is also present");
1016 #endif /* PNG_READ_sRGB_SUPPORTED */
1018 #ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1019 /* Store the _white values as default coefficients for the rgb to gray
1020 * operation if it is supported. Check if the transform is already set to
1021 * avoid destroying the transform values.
1023 if (!png_ptr
->rgb_to_gray_coefficients_set
)
1025 /* png_set_background has not been called and we haven't seen an sRGB
1026 * chunk yet. Find the XYZ of the three end points.
1033 xy
.greenx
= x_green
;
1034 xy
.greeny
= y_green
;
1037 xy
.whitex
= x_white
;
1038 xy
.whitey
= y_white
;
1040 if (png_XYZ_from_xy_checked(png_ptr
, &XYZ
, xy
))
1042 /* The success case, because XYZ_from_xy normalises to a reference
1043 * white Y of 1.0 we just need to scale the numbers. This should
1044 * always work just fine. It is an internal error if this overflows.
1047 png_fixed_point r
, g
, b
;
1048 if (png_muldiv(&r
, XYZ
.redY
, 32768, PNG_FP_1
) &&
1049 r
>= 0 && r
<= 32768 &&
1050 png_muldiv(&g
, XYZ
.greenY
, 32768, PNG_FP_1
) &&
1051 g
>= 0 && g
<= 32768 &&
1052 png_muldiv(&b
, XYZ
.blueY
, 32768, PNG_FP_1
) &&
1053 b
>= 0 && b
<= 32768 &&
1056 /* We allow 0 coefficients here. r+g+b may be 32769 if two or
1057 * all of the coefficients were rounded up. Handle this by
1058 * reducing the *largest* coefficient by 1; this matches the
1059 * approach used for the default coefficients in pngrtran.c
1065 else if (r
+g
+b
< 32768)
1070 if (g
>= r
&& g
>= b
)
1072 else if (r
>= g
&& r
>= b
)
1078 /* Check for an internal error. */
1081 "internal error handling cHRM coefficients");
1083 png_ptr
->rgb_to_gray_red_coeff
= (png_uint_16
)r
;
1084 png_ptr
->rgb_to_gray_green_coeff
= (png_uint_16
)g
;
1087 /* This is a png_error at present even though it could be ignored -
1088 * it should never happen, but it is important that if it does, the
1092 png_error(png_ptr
, "internal error handling cHRM->XYZ");
1098 png_set_cHRM_fixed(png_ptr
, info_ptr
, x_white
, y_white
, x_red
, y_red
,
1099 x_green
, y_green
, x_blue
, y_blue
);
1103 #ifdef PNG_READ_sRGB_SUPPORTED
1105 png_handle_sRGB(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1110 png_debug(1, "in png_handle_sRGB");
1112 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1113 png_error(png_ptr
, "Missing IHDR before sRGB");
1115 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1117 png_warning(png_ptr
, "Invalid sRGB after IDAT");
1118 png_crc_finish(png_ptr
, length
);
1122 else if (png_ptr
->mode
& PNG_HAVE_PLTE
)
1123 /* Should be an error, but we can cope with it */
1124 png_warning(png_ptr
, "Out of place sRGB chunk");
1126 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_sRGB
))
1128 png_warning(png_ptr
, "Duplicate sRGB chunk");
1129 png_crc_finish(png_ptr
, length
);
1135 png_warning(png_ptr
, "Incorrect sRGB chunk length");
1136 png_crc_finish(png_ptr
, length
);
1140 png_crc_read(png_ptr
, buf
, 1);
1142 if (png_crc_finish(png_ptr
, 0))
1147 /* Check for bad intent */
1148 if (intent
>= PNG_sRGB_INTENT_LAST
)
1150 png_warning(png_ptr
, "Unknown sRGB intent");
1154 #if defined(PNG_READ_gAMA_SUPPORTED) && defined(PNG_READ_GAMMA_SUPPORTED)
1155 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_gAMA
))
1157 if (PNG_OUT_OF_RANGE(info_ptr
->gamma
, 45500, 500))
1159 PNG_WARNING_PARAMETERS(p
)
1161 png_warning_parameter_signed(p
, 1, PNG_NUMBER_FORMAT_fixed
,
1164 png_formatted_warning(png_ptr
, p
,
1165 "Ignoring incorrect gAMA value @1 when sRGB is also present");
1168 #endif /* PNG_READ_gAMA_SUPPORTED */
1170 #ifdef PNG_READ_cHRM_SUPPORTED
1171 if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_cHRM
))
1172 if (PNG_OUT_OF_RANGE(info_ptr
->x_white
, 31270, 1000) ||
1173 PNG_OUT_OF_RANGE(info_ptr
->y_white
, 32900, 1000) ||
1174 PNG_OUT_OF_RANGE(info_ptr
->x_red
, 64000, 1000) ||
1175 PNG_OUT_OF_RANGE(info_ptr
->y_red
, 33000, 1000) ||
1176 PNG_OUT_OF_RANGE(info_ptr
->x_green
, 30000, 1000) ||
1177 PNG_OUT_OF_RANGE(info_ptr
->y_green
, 60000, 1000) ||
1178 PNG_OUT_OF_RANGE(info_ptr
->x_blue
, 15000, 1000) ||
1179 PNG_OUT_OF_RANGE(info_ptr
->y_blue
, 6000, 1000))
1181 png_warning(png_ptr
,
1182 "Ignoring incorrect cHRM value when sRGB is also present");
1184 #endif /* PNG_READ_cHRM_SUPPORTED */
1186 /* This is recorded for use when handling the cHRM chunk above. An sRGB
1187 * chunk unconditionally overwrites the coefficients for grayscale conversion
1190 png_ptr
->is_sRGB
= 1;
1192 # ifdef PNG_READ_RGB_TO_GRAY_SUPPORTED
1193 /* Don't overwrite user supplied values: */
1194 if (!png_ptr
->rgb_to_gray_coefficients_set
)
1196 /* These numbers come from the sRGB specification (or, since one has to
1197 * pay much money to get a copy, the wikipedia sRGB page) the
1198 * chromaticity values quoted have been inverted to get the reverse
1199 * transformation from RGB to XYZ and the 'Y' coefficients scaled by
1200 * 32768 (then rounded).
1202 * sRGB and ITU Rec-709 both truncate the values for the D65 white
1203 * point to four digits and, even though it actually stores five
1204 * digits, the PNG spec gives the truncated value.
1206 * This means that when the chromaticities are converted back to XYZ
1207 * end points we end up with (6968,23435,2366), which, as described in
1208 * pngrtran.c, would overflow. If the five digit precision and up is
1209 * used we get, instead:
1211 * 6968*R + 23435*G + 2365*B
1213 * (Notice that this rounds the blue coefficient down, rather than the
1214 * choice used in pngrtran.c which is to round the green one down.)
1216 png_ptr
->rgb_to_gray_red_coeff
= 6968; /* 0.212639005871510 */
1217 png_ptr
->rgb_to_gray_green_coeff
= 23434; /* 0.715168678767756 */
1218 /* png_ptr->rgb_to_gray_blue_coeff = 2366; 0.072192315360734 */
1220 /* The following keeps the cHRM chunk from destroying the
1221 * coefficients again in the event that it follows the sRGB chunk.
1223 png_ptr
->rgb_to_gray_coefficients_set
= 1;
1227 png_set_sRGB_gAMA_and_cHRM(png_ptr
, info_ptr
, intent
);
1229 #endif /* PNG_READ_sRGB_SUPPORTED */
1231 #ifdef PNG_READ_iCCP_SUPPORTED
1233 png_handle_iCCP(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1234 /* Note: this does not properly handle chunks that are > 64K under DOS */
1236 png_byte compression_type
;
1239 png_uint_32 skip
= 0;
1240 png_uint_32 profile_size
;
1241 png_alloc_size_t profile_length
;
1242 png_size_t slength
, prefix_length
, data_length
;
1244 png_debug(1, "in png_handle_iCCP");
1246 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1247 png_error(png_ptr
, "Missing IHDR before iCCP");
1249 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1251 png_warning(png_ptr
, "Invalid iCCP after IDAT");
1252 png_crc_finish(png_ptr
, length
);
1256 else if (png_ptr
->mode
& PNG_HAVE_PLTE
)
1257 /* Should be an error, but we can cope with it */
1258 png_warning(png_ptr
, "Out of place iCCP chunk");
1260 if ((png_ptr
->mode
& PNG_HAVE_iCCP
) || (info_ptr
!= NULL
&&
1261 (info_ptr
->valid
& (PNG_INFO_iCCP
|PNG_INFO_sRGB
))))
1263 png_warning(png_ptr
, "Duplicate iCCP chunk");
1264 png_crc_finish(png_ptr
, length
);
1268 png_ptr
->mode
|= PNG_HAVE_iCCP
;
1270 #ifdef PNG_MAX_MALLOC_64K
1271 if (length
> (png_uint_32
)65535L)
1273 png_warning(png_ptr
, "iCCP chunk too large to fit in memory");
1274 skip
= length
- (png_uint_32
)65535L;
1275 length
= (png_uint_32
)65535L;
1279 png_free(png_ptr
, png_ptr
->chunkdata
);
1280 png_ptr
->chunkdata
= (png_charp
)png_malloc(png_ptr
, length
+ 1);
1282 png_crc_read(png_ptr
, (png_bytep
)png_ptr
->chunkdata
, slength
);
1284 if (png_crc_finish(png_ptr
, skip
))
1286 png_free(png_ptr
, png_ptr
->chunkdata
);
1287 png_ptr
->chunkdata
= NULL
;
1291 png_ptr
->chunkdata
[slength
] = 0x00;
1293 for (profile
= png_ptr
->chunkdata
; *profile
; profile
++)
1294 /* Empty loop to find end of name */ ;
1298 /* There should be at least one zero (the compression type byte)
1299 * following the separator, and we should be on it
1301 if (profile
>= png_ptr
->chunkdata
+ slength
- 1)
1303 png_free(png_ptr
, png_ptr
->chunkdata
);
1304 png_ptr
->chunkdata
= NULL
;
1305 png_warning(png_ptr
, "Malformed iCCP chunk");
1309 /* Compression_type should always be zero */
1310 compression_type
= *profile
++;
1312 if (compression_type
)
1314 png_warning(png_ptr
, "Ignoring nonzero compression type in iCCP chunk");
1315 compression_type
= 0x00; /* Reset it to zero (libpng-1.0.6 through 1.0.8
1319 prefix_length
= profile
- png_ptr
->chunkdata
;
1320 png_decompress_chunk(png_ptr
, compression_type
,
1321 slength
, prefix_length
, &data_length
);
1323 profile_length
= data_length
- prefix_length
;
1325 if (prefix_length
> data_length
|| profile_length
< 4)
1327 png_free(png_ptr
, png_ptr
->chunkdata
);
1328 png_ptr
->chunkdata
= NULL
;
1329 png_warning(png_ptr
, "Profile size field missing from iCCP chunk");
1333 /* Check the profile_size recorded in the first 32 bits of the ICC profile */
1334 pC
= (png_bytep
)(png_ptr
->chunkdata
+ prefix_length
);
1335 profile_size
= ((*(pC
)) << 24) |
1336 ((*(pC
+ 1)) << 16) |
1337 ((*(pC
+ 2)) << 8) |
1340 /* NOTE: the following guarantees that 'profile_length' fits into 32 bits,
1341 * because profile_size is a 32 bit value.
1343 if (profile_size
< profile_length
)
1344 profile_length
= profile_size
;
1346 /* And the following guarantees that profile_size == profile_length. */
1347 if (profile_size
> profile_length
)
1349 PNG_WARNING_PARAMETERS(p
)
1351 png_free(png_ptr
, png_ptr
->chunkdata
);
1352 png_ptr
->chunkdata
= NULL
;
1354 png_warning_parameter_unsigned(p
, 1, PNG_NUMBER_FORMAT_u
, profile_size
);
1355 png_warning_parameter_unsigned(p
, 2, PNG_NUMBER_FORMAT_u
, profile_length
);
1356 png_formatted_warning(png_ptr
, p
,
1357 "Ignoring iCCP chunk with declared size = @1 and actual length = @2");
1361 png_set_iCCP(png_ptr
, info_ptr
, png_ptr
->chunkdata
,
1362 compression_type
, (png_bytep
)png_ptr
->chunkdata
+ prefix_length
,
1364 png_free(png_ptr
, png_ptr
->chunkdata
);
1365 png_ptr
->chunkdata
= NULL
;
1367 #endif /* PNG_READ_iCCP_SUPPORTED */
1369 #ifdef PNG_READ_sPLT_SUPPORTED
1371 png_handle_sPLT(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1372 /* Note: this does not properly handle chunks that are > 64K under DOS */
1374 png_bytep entry_start
;
1375 png_sPLT_t new_palette
;
1377 png_uint_32 data_length
;
1379 png_uint_32 skip
= 0;
1384 png_debug(1, "in png_handle_sPLT");
1386 #ifdef PNG_USER_LIMITS_SUPPORTED
1388 if (png_ptr
->user_chunk_cache_max
!= 0)
1390 if (png_ptr
->user_chunk_cache_max
== 1)
1392 png_crc_finish(png_ptr
, length
);
1396 if (--png_ptr
->user_chunk_cache_max
== 1)
1398 png_warning(png_ptr
, "No space in chunk cache for sPLT");
1399 png_crc_finish(png_ptr
, length
);
1405 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1406 png_error(png_ptr
, "Missing IHDR before sPLT");
1408 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1410 png_warning(png_ptr
, "Invalid sPLT after IDAT");
1411 png_crc_finish(png_ptr
, length
);
1415 #ifdef PNG_MAX_MALLOC_64K
1416 if (length
> (png_uint_32
)65535L)
1418 png_warning(png_ptr
, "sPLT chunk too large to fit in memory");
1419 skip
= length
- (png_uint_32
)65535L;
1420 length
= (png_uint_32
)65535L;
1424 png_free(png_ptr
, png_ptr
->chunkdata
);
1425 png_ptr
->chunkdata
= (png_charp
)png_malloc(png_ptr
, length
+ 1);
1427 /* WARNING: this may break if size_t is less than 32 bits; it is assumed
1428 * that the PNG_MAX_MALLOC_64K test is enabled in this case, but this is a
1429 * potential breakage point if the types in pngconf.h aren't exactly right.
1432 png_crc_read(png_ptr
, (png_bytep
)png_ptr
->chunkdata
, slength
);
1434 if (png_crc_finish(png_ptr
, skip
))
1436 png_free(png_ptr
, png_ptr
->chunkdata
);
1437 png_ptr
->chunkdata
= NULL
;
1441 png_ptr
->chunkdata
[slength
] = 0x00;
1443 for (entry_start
= (png_bytep
)png_ptr
->chunkdata
; *entry_start
;
1445 /* Empty loop to find end of name */ ;
1449 /* A sample depth should follow the separator, and we should be on it */
1450 if (entry_start
> (png_bytep
)png_ptr
->chunkdata
+ slength
- 2)
1452 png_free(png_ptr
, png_ptr
->chunkdata
);
1453 png_ptr
->chunkdata
= NULL
;
1454 png_warning(png_ptr
, "malformed sPLT chunk");
1458 new_palette
.depth
= *entry_start
++;
1459 entry_size
= (new_palette
.depth
== 8 ? 6 : 10);
1460 /* This must fit in a png_uint_32 because it is derived from the original
1461 * chunk data length (and use 'length', not 'slength' here for clarity -
1462 * they are guaranteed to be the same, see the tests above.)
1464 data_length
= length
- (png_uint_32
)(entry_start
-
1465 (png_bytep
)png_ptr
->chunkdata
);
1467 /* Integrity-check the data length */
1468 if (data_length
% entry_size
)
1470 png_free(png_ptr
, png_ptr
->chunkdata
);
1471 png_ptr
->chunkdata
= NULL
;
1472 png_warning(png_ptr
, "sPLT chunk has bad length");
1476 dl
= (png_int_32
)(data_length
/ entry_size
);
1477 max_dl
= PNG_SIZE_MAX
/ png_sizeof(png_sPLT_entry
);
1481 png_warning(png_ptr
, "sPLT chunk too long");
1485 new_palette
.nentries
= (png_int_32
)(data_length
/ entry_size
);
1487 new_palette
.entries
= (png_sPLT_entryp
)png_malloc_warn(
1488 png_ptr
, new_palette
.nentries
* png_sizeof(png_sPLT_entry
));
1490 if (new_palette
.entries
== NULL
)
1492 png_warning(png_ptr
, "sPLT chunk requires too much memory");
1496 #ifdef PNG_POINTER_INDEXING_SUPPORTED
1497 for (i
= 0; i
< new_palette
.nentries
; i
++)
1499 pp
= new_palette
.entries
+ i
;
1501 if (new_palette
.depth
== 8)
1503 pp
->red
= *entry_start
++;
1504 pp
->green
= *entry_start
++;
1505 pp
->blue
= *entry_start
++;
1506 pp
->alpha
= *entry_start
++;
1511 pp
->red
= png_get_uint_16(entry_start
); entry_start
+= 2;
1512 pp
->green
= png_get_uint_16(entry_start
); entry_start
+= 2;
1513 pp
->blue
= png_get_uint_16(entry_start
); entry_start
+= 2;
1514 pp
->alpha
= png_get_uint_16(entry_start
); entry_start
+= 2;
1517 pp
->frequency
= png_get_uint_16(entry_start
); entry_start
+= 2;
1520 pp
= new_palette
.entries
;
1522 for (i
= 0; i
< new_palette
.nentries
; i
++)
1525 if (new_palette
.depth
== 8)
1527 pp
[i
].red
= *entry_start
++;
1528 pp
[i
].green
= *entry_start
++;
1529 pp
[i
].blue
= *entry_start
++;
1530 pp
[i
].alpha
= *entry_start
++;
1535 pp
[i
].red
= png_get_uint_16(entry_start
); entry_start
+= 2;
1536 pp
[i
].green
= png_get_uint_16(entry_start
); entry_start
+= 2;
1537 pp
[i
].blue
= png_get_uint_16(entry_start
); entry_start
+= 2;
1538 pp
[i
].alpha
= png_get_uint_16(entry_start
); entry_start
+= 2;
1541 pp
[i
].frequency
= png_get_uint_16(entry_start
); entry_start
+= 2;
1545 /* Discard all chunk data except the name and stash that */
1546 new_palette
.name
= png_ptr
->chunkdata
;
1548 png_set_sPLT(png_ptr
, info_ptr
, &new_palette
, 1);
1550 png_free(png_ptr
, png_ptr
->chunkdata
);
1551 png_ptr
->chunkdata
= NULL
;
1552 png_free(png_ptr
, new_palette
.entries
);
1554 #endif /* PNG_READ_sPLT_SUPPORTED */
1556 #ifdef PNG_READ_tRNS_SUPPORTED
1558 png_handle_tRNS(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1560 png_byte readbuf
[PNG_MAX_PALETTE_LENGTH
];
1562 png_debug(1, "in png_handle_tRNS");
1564 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1565 png_error(png_ptr
, "Missing IHDR before tRNS");
1567 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1569 png_warning(png_ptr
, "Invalid tRNS after IDAT");
1570 png_crc_finish(png_ptr
, length
);
1574 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_tRNS
))
1576 png_warning(png_ptr
, "Duplicate tRNS chunk");
1577 png_crc_finish(png_ptr
, length
);
1581 if (png_ptr
->color_type
== PNG_COLOR_TYPE_GRAY
)
1587 png_warning(png_ptr
, "Incorrect tRNS chunk length");
1588 png_crc_finish(png_ptr
, length
);
1592 png_crc_read(png_ptr
, buf
, 2);
1593 png_ptr
->num_trans
= 1;
1594 png_ptr
->trans_color
.gray
= png_get_uint_16(buf
);
1597 else if (png_ptr
->color_type
== PNG_COLOR_TYPE_RGB
)
1603 png_warning(png_ptr
, "Incorrect tRNS chunk length");
1604 png_crc_finish(png_ptr
, length
);
1608 png_crc_read(png_ptr
, buf
, (png_size_t
)length
);
1609 png_ptr
->num_trans
= 1;
1610 png_ptr
->trans_color
.red
= png_get_uint_16(buf
);
1611 png_ptr
->trans_color
.green
= png_get_uint_16(buf
+ 2);
1612 png_ptr
->trans_color
.blue
= png_get_uint_16(buf
+ 4);
1615 else if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
1617 if (!(png_ptr
->mode
& PNG_HAVE_PLTE
))
1619 /* Should be an error, but we can cope with it. */
1620 png_warning(png_ptr
, "Missing PLTE before tRNS");
1623 if (length
> (png_uint_32
)png_ptr
->num_palette
||
1624 length
> PNG_MAX_PALETTE_LENGTH
)
1626 png_warning(png_ptr
, "Incorrect tRNS chunk length");
1627 png_crc_finish(png_ptr
, length
);
1633 png_warning(png_ptr
, "Zero length tRNS chunk");
1634 png_crc_finish(png_ptr
, length
);
1638 png_crc_read(png_ptr
, readbuf
, (png_size_t
)length
);
1639 png_ptr
->num_trans
= (png_uint_16
)length
;
1644 png_warning(png_ptr
, "tRNS chunk not allowed with alpha channel");
1645 png_crc_finish(png_ptr
, length
);
1649 if (png_crc_finish(png_ptr
, 0))
1651 png_ptr
->num_trans
= 0;
1655 png_set_tRNS(png_ptr
, info_ptr
, readbuf
, png_ptr
->num_trans
,
1656 &(png_ptr
->trans_color
));
1660 #ifdef PNG_READ_bKGD_SUPPORTED
1662 png_handle_bKGD(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1666 png_color_16 background
;
1668 png_debug(1, "in png_handle_bKGD");
1670 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1671 png_error(png_ptr
, "Missing IHDR before bKGD");
1673 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1675 png_warning(png_ptr
, "Invalid bKGD after IDAT");
1676 png_crc_finish(png_ptr
, length
);
1680 else if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
&&
1681 !(png_ptr
->mode
& PNG_HAVE_PLTE
))
1683 png_warning(png_ptr
, "Missing PLTE before bKGD");
1684 png_crc_finish(png_ptr
, length
);
1688 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_bKGD
))
1690 png_warning(png_ptr
, "Duplicate bKGD chunk");
1691 png_crc_finish(png_ptr
, length
);
1695 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
1698 else if (png_ptr
->color_type
& PNG_COLOR_MASK_COLOR
)
1704 if (length
!= truelen
)
1706 png_warning(png_ptr
, "Incorrect bKGD chunk length");
1707 png_crc_finish(png_ptr
, length
);
1711 png_crc_read(png_ptr
, buf
, truelen
);
1713 if (png_crc_finish(png_ptr
, 0))
1716 /* We convert the index value into RGB components so that we can allow
1717 * arbitrary RGB values for background when we have transparency, and
1718 * so it is easy to determine the RGB values of the background color
1719 * from the info_ptr struct.
1721 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
1723 background
.index
= buf
[0];
1725 if (info_ptr
&& info_ptr
->num_palette
)
1727 if (buf
[0] >= info_ptr
->num_palette
)
1729 png_warning(png_ptr
, "Incorrect bKGD chunk index value");
1733 background
.red
= (png_uint_16
)png_ptr
->palette
[buf
[0]].red
;
1734 background
.green
= (png_uint_16
)png_ptr
->palette
[buf
[0]].green
;
1735 background
.blue
= (png_uint_16
)png_ptr
->palette
[buf
[0]].blue
;
1739 background
.red
= background
.green
= background
.blue
= 0;
1741 background
.gray
= 0;
1744 else if (!(png_ptr
->color_type
& PNG_COLOR_MASK_COLOR
)) /* GRAY */
1746 background
.index
= 0;
1750 background
.gray
= png_get_uint_16(buf
);
1755 background
.index
= 0;
1756 background
.red
= png_get_uint_16(buf
);
1757 background
.green
= png_get_uint_16(buf
+ 2);
1758 background
.blue
= png_get_uint_16(buf
+ 4);
1759 background
.gray
= 0;
1762 png_set_bKGD(png_ptr
, info_ptr
, &background
);
1766 #ifdef PNG_READ_hIST_SUPPORTED
1768 png_handle_hIST(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1770 unsigned int num
, i
;
1771 png_uint_16 readbuf
[PNG_MAX_PALETTE_LENGTH
];
1773 png_debug(1, "in png_handle_hIST");
1775 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1776 png_error(png_ptr
, "Missing IHDR before hIST");
1778 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1780 png_warning(png_ptr
, "Invalid hIST after IDAT");
1781 png_crc_finish(png_ptr
, length
);
1785 else if (!(png_ptr
->mode
& PNG_HAVE_PLTE
))
1787 png_warning(png_ptr
, "Missing PLTE before hIST");
1788 png_crc_finish(png_ptr
, length
);
1792 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_hIST
))
1794 png_warning(png_ptr
, "Duplicate hIST chunk");
1795 png_crc_finish(png_ptr
, length
);
1799 if (length
> 2*PNG_MAX_PALETTE_LENGTH
||
1800 length
!= (unsigned int) (2*png_ptr
->num_palette
))
1802 png_warning(png_ptr
, "Incorrect hIST chunk length");
1803 png_crc_finish(png_ptr
, length
);
1809 for (i
= 0; i
< num
; i
++)
1813 png_crc_read(png_ptr
, buf
, 2);
1814 readbuf
[i
] = png_get_uint_16(buf
);
1817 if (png_crc_finish(png_ptr
, 0))
1820 png_set_hIST(png_ptr
, info_ptr
, readbuf
);
1824 #ifdef PNG_READ_pHYs_SUPPORTED
1826 png_handle_pHYs(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1829 png_uint_32 res_x
, res_y
;
1832 png_debug(1, "in png_handle_pHYs");
1834 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1835 png_error(png_ptr
, "Missing IHDR before pHYs");
1837 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1839 png_warning(png_ptr
, "Invalid pHYs after IDAT");
1840 png_crc_finish(png_ptr
, length
);
1844 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_pHYs
))
1846 png_warning(png_ptr
, "Duplicate pHYs chunk");
1847 png_crc_finish(png_ptr
, length
);
1853 png_warning(png_ptr
, "Incorrect pHYs chunk length");
1854 png_crc_finish(png_ptr
, length
);
1858 png_crc_read(png_ptr
, buf
, 9);
1860 if (png_crc_finish(png_ptr
, 0))
1863 res_x
= png_get_uint_32(buf
);
1864 res_y
= png_get_uint_32(buf
+ 4);
1866 png_set_pHYs(png_ptr
, info_ptr
, res_x
, res_y
, unit_type
);
1870 #ifdef PNG_READ_oFFs_SUPPORTED
1872 png_handle_oFFs(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1875 png_int_32 offset_x
, offset_y
;
1878 png_debug(1, "in png_handle_oFFs");
1880 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1881 png_error(png_ptr
, "Missing IHDR before oFFs");
1883 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1885 png_warning(png_ptr
, "Invalid oFFs after IDAT");
1886 png_crc_finish(png_ptr
, length
);
1890 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_oFFs
))
1892 png_warning(png_ptr
, "Duplicate oFFs chunk");
1893 png_crc_finish(png_ptr
, length
);
1899 png_warning(png_ptr
, "Incorrect oFFs chunk length");
1900 png_crc_finish(png_ptr
, length
);
1904 png_crc_read(png_ptr
, buf
, 9);
1906 if (png_crc_finish(png_ptr
, 0))
1909 offset_x
= png_get_int_32(buf
);
1910 offset_y
= png_get_int_32(buf
+ 4);
1912 png_set_oFFs(png_ptr
, info_ptr
, offset_x
, offset_y
, unit_type
);
1916 #ifdef PNG_READ_pCAL_SUPPORTED
1917 /* Read the pCAL chunk (described in the PNG Extensions document) */
1919 png_handle_pCAL(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
1922 png_byte type
, nparams
;
1923 png_charp buf
, units
, endptr
;
1928 png_debug(1, "in png_handle_pCAL");
1930 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
1931 png_error(png_ptr
, "Missing IHDR before pCAL");
1933 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
1935 png_warning(png_ptr
, "Invalid pCAL after IDAT");
1936 png_crc_finish(png_ptr
, length
);
1940 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_pCAL
))
1942 png_warning(png_ptr
, "Duplicate pCAL chunk");
1943 png_crc_finish(png_ptr
, length
);
1947 png_debug1(2, "Allocating and reading pCAL chunk data (%u bytes)",
1949 png_free(png_ptr
, png_ptr
->chunkdata
);
1950 png_ptr
->chunkdata
= (png_charp
)png_malloc_warn(png_ptr
, length
+ 1);
1952 if (png_ptr
->chunkdata
== NULL
)
1954 png_warning(png_ptr
, "No memory for pCAL purpose");
1959 png_crc_read(png_ptr
, (png_bytep
)png_ptr
->chunkdata
, slength
);
1961 if (png_crc_finish(png_ptr
, 0))
1963 png_free(png_ptr
, png_ptr
->chunkdata
);
1964 png_ptr
->chunkdata
= NULL
;
1968 png_ptr
->chunkdata
[slength
] = 0x00; /* Null terminate the last string */
1970 png_debug(3, "Finding end of pCAL purpose string");
1971 for (buf
= png_ptr
->chunkdata
; *buf
; buf
++)
1974 endptr
= png_ptr
->chunkdata
+ slength
;
1976 /* We need to have at least 12 bytes after the purpose string
1977 * in order to get the parameter information.
1979 if (endptr
<= buf
+ 12)
1981 png_warning(png_ptr
, "Invalid pCAL data");
1982 png_free(png_ptr
, png_ptr
->chunkdata
);
1983 png_ptr
->chunkdata
= NULL
;
1987 png_debug(3, "Reading pCAL X0, X1, type, nparams, and units");
1988 X0
= png_get_int_32((png_bytep
)buf
+1);
1989 X1
= png_get_int_32((png_bytep
)buf
+5);
1994 png_debug(3, "Checking pCAL equation type and number of parameters");
1995 /* Check that we have the right number of parameters for known
1998 if ((type
== PNG_EQUATION_LINEAR
&& nparams
!= 2) ||
1999 (type
== PNG_EQUATION_BASE_E
&& nparams
!= 3) ||
2000 (type
== PNG_EQUATION_ARBITRARY
&& nparams
!= 3) ||
2001 (type
== PNG_EQUATION_HYPERBOLIC
&& nparams
!= 4))
2003 png_warning(png_ptr
, "Invalid pCAL parameters for equation type");
2004 png_free(png_ptr
, png_ptr
->chunkdata
);
2005 png_ptr
->chunkdata
= NULL
;
2009 else if (type
>= PNG_EQUATION_LAST
)
2011 png_warning(png_ptr
, "Unrecognized equation type for pCAL chunk");
2014 for (buf
= units
; *buf
; buf
++)
2015 /* Empty loop to move past the units string. */ ;
2017 png_debug(3, "Allocating pCAL parameters array");
2019 params
= (png_charpp
)png_malloc_warn(png_ptr
,
2020 (png_size_t
)(nparams
* png_sizeof(png_charp
)));
2024 png_free(png_ptr
, png_ptr
->chunkdata
);
2025 png_ptr
->chunkdata
= NULL
;
2026 png_warning(png_ptr
, "No memory for pCAL params");
2030 /* Get pointers to the start of each parameter string. */
2031 for (i
= 0; i
< (int)nparams
; i
++)
2033 buf
++; /* Skip the null string terminator from previous parameter. */
2035 png_debug1(3, "Reading pCAL parameter %d", i
);
2037 for (params
[i
] = buf
; buf
<= endptr
&& *buf
!= 0x00; buf
++)
2038 /* Empty loop to move past each parameter string */ ;
2040 /* Make sure we haven't run out of data yet */
2043 png_warning(png_ptr
, "Invalid pCAL data");
2044 png_free(png_ptr
, png_ptr
->chunkdata
);
2045 png_ptr
->chunkdata
= NULL
;
2046 png_free(png_ptr
, params
);
2051 png_set_pCAL(png_ptr
, info_ptr
, png_ptr
->chunkdata
, X0
, X1
, type
, nparams
,
2054 png_free(png_ptr
, png_ptr
->chunkdata
);
2055 png_ptr
->chunkdata
= NULL
;
2056 png_free(png_ptr
, params
);
2060 #ifdef PNG_READ_sCAL_SUPPORTED
2061 /* Read the sCAL chunk */
2063 png_handle_sCAL(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
2065 png_size_t slength
, i
;
2068 png_debug(1, "in png_handle_sCAL");
2070 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
2071 png_error(png_ptr
, "Missing IHDR before sCAL");
2073 else if (png_ptr
->mode
& PNG_HAVE_IDAT
)
2075 png_warning(png_ptr
, "Invalid sCAL after IDAT");
2076 png_crc_finish(png_ptr
, length
);
2080 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_sCAL
))
2082 png_warning(png_ptr
, "Duplicate sCAL chunk");
2083 png_crc_finish(png_ptr
, length
);
2087 /* Need unit type, width, \0, height: minimum 4 bytes */
2088 else if (length
< 4)
2090 png_warning(png_ptr
, "sCAL chunk too short");
2091 png_crc_finish(png_ptr
, length
);
2095 png_debug1(2, "Allocating and reading sCAL chunk data (%u bytes)",
2098 png_ptr
->chunkdata
= (png_charp
)png_malloc_warn(png_ptr
, length
+ 1);
2100 if (png_ptr
->chunkdata
== NULL
)
2102 png_warning(png_ptr
, "Out of memory while processing sCAL chunk");
2103 png_crc_finish(png_ptr
, length
);
2108 png_crc_read(png_ptr
, (png_bytep
)png_ptr
->chunkdata
, slength
);
2109 png_ptr
->chunkdata
[slength
] = 0x00; /* Null terminate the last string */
2111 if (png_crc_finish(png_ptr
, 0))
2113 png_free(png_ptr
, png_ptr
->chunkdata
);
2114 png_ptr
->chunkdata
= NULL
;
2118 /* Validate the unit. */
2119 if (png_ptr
->chunkdata
[0] != 1 && png_ptr
->chunkdata
[0] != 2)
2121 png_warning(png_ptr
, "Invalid sCAL ignored: invalid unit");
2122 png_free(png_ptr
, png_ptr
->chunkdata
);
2123 png_ptr
->chunkdata
= NULL
;
2127 /* Validate the ASCII numbers, need two ASCII numbers separated by
2128 * a '\0' and they need to fit exactly in the chunk data.
2133 if (!png_check_fp_number(png_ptr
->chunkdata
, slength
, &state
, &i
) ||
2134 i
>= slength
|| png_ptr
->chunkdata
[i
++] != 0)
2135 png_warning(png_ptr
, "Invalid sCAL chunk ignored: bad width format");
2137 else if (!PNG_FP_IS_POSITIVE(state
))
2138 png_warning(png_ptr
, "Invalid sCAL chunk ignored: non-positive width");
2142 png_size_t heighti
= i
;
2145 if (!png_check_fp_number(png_ptr
->chunkdata
, slength
, &state
, &i
) ||
2147 png_warning(png_ptr
, "Invalid sCAL chunk ignored: bad height format");
2149 else if (!PNG_FP_IS_POSITIVE(state
))
2150 png_warning(png_ptr
,
2151 "Invalid sCAL chunk ignored: non-positive height");
2154 /* This is the (only) success case. */
2155 png_set_sCAL_s(png_ptr
, info_ptr
, png_ptr
->chunkdata
[0],
2156 png_ptr
->chunkdata
+1, png_ptr
->chunkdata
+heighti
);
2159 /* Clean up - just free the temporarily allocated buffer. */
2160 png_free(png_ptr
, png_ptr
->chunkdata
);
2161 png_ptr
->chunkdata
= NULL
;
2165 #ifdef PNG_READ_tIME_SUPPORTED
2167 png_handle_tIME(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
2172 png_debug(1, "in png_handle_tIME");
2174 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
2175 png_error(png_ptr
, "Out of place tIME chunk");
2177 else if (info_ptr
!= NULL
&& (info_ptr
->valid
& PNG_INFO_tIME
))
2179 png_warning(png_ptr
, "Duplicate tIME chunk");
2180 png_crc_finish(png_ptr
, length
);
2184 if (png_ptr
->mode
& PNG_HAVE_IDAT
)
2185 png_ptr
->mode
|= PNG_AFTER_IDAT
;
2189 png_warning(png_ptr
, "Incorrect tIME chunk length");
2190 png_crc_finish(png_ptr
, length
);
2194 png_crc_read(png_ptr
, buf
, 7);
2196 if (png_crc_finish(png_ptr
, 0))
2199 mod_time
.second
= buf
[6];
2200 mod_time
.minute
= buf
[5];
2201 mod_time
.hour
= buf
[4];
2202 mod_time
.day
= buf
[3];
2203 mod_time
.month
= buf
[2];
2204 mod_time
.year
= png_get_uint_16(buf
);
2206 png_set_tIME(png_ptr
, info_ptr
, &mod_time
);
2210 #ifdef PNG_READ_tEXt_SUPPORTED
2211 /* Note: this does not properly handle chunks that are > 64K under DOS */
2213 png_handle_tEXt(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
2218 png_uint_32 skip
= 0;
2222 png_debug(1, "in png_handle_tEXt");
2224 #ifdef PNG_USER_LIMITS_SUPPORTED
2225 if (png_ptr
->user_chunk_cache_max
!= 0)
2227 if (png_ptr
->user_chunk_cache_max
== 1)
2229 png_crc_finish(png_ptr
, length
);
2233 if (--png_ptr
->user_chunk_cache_max
== 1)
2235 png_warning(png_ptr
, "No space in chunk cache for tEXt");
2236 png_crc_finish(png_ptr
, length
);
2242 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
2243 png_error(png_ptr
, "Missing IHDR before tEXt");
2245 if (png_ptr
->mode
& PNG_HAVE_IDAT
)
2246 png_ptr
->mode
|= PNG_AFTER_IDAT
;
2248 #ifdef PNG_MAX_MALLOC_64K
2249 if (length
> (png_uint_32
)65535L)
2251 png_warning(png_ptr
, "tEXt chunk too large to fit in memory");
2252 skip
= length
- (png_uint_32
)65535L;
2253 length
= (png_uint_32
)65535L;
2257 png_free(png_ptr
, png_ptr
->chunkdata
);
2259 png_ptr
->chunkdata
= (png_charp
)png_malloc_warn(png_ptr
, length
+ 1);
2261 if (png_ptr
->chunkdata
== NULL
)
2263 png_warning(png_ptr
, "No memory to process text chunk");
2268 png_crc_read(png_ptr
, (png_bytep
)png_ptr
->chunkdata
, slength
);
2270 if (png_crc_finish(png_ptr
, skip
))
2272 png_free(png_ptr
, png_ptr
->chunkdata
);
2273 png_ptr
->chunkdata
= NULL
;
2277 key
= png_ptr
->chunkdata
;
2279 key
[slength
] = 0x00;
2281 for (text
= key
; *text
; text
++)
2282 /* Empty loop to find end of key */ ;
2284 if (text
!= key
+ slength
)
2287 text_ptr
= (png_textp
)png_malloc_warn(png_ptr
,
2288 png_sizeof(png_text
));
2290 if (text_ptr
== NULL
)
2292 png_warning(png_ptr
, "Not enough memory to process text chunk");
2293 png_free(png_ptr
, png_ptr
->chunkdata
);
2294 png_ptr
->chunkdata
= NULL
;
2298 text_ptr
->compression
= PNG_TEXT_COMPRESSION_NONE
;
2299 text_ptr
->key
= key
;
2300 text_ptr
->lang
= NULL
;
2301 text_ptr
->lang_key
= NULL
;
2302 text_ptr
->itxt_length
= 0;
2303 text_ptr
->text
= text
;
2304 text_ptr
->text_length
= png_strlen(text
);
2306 ret
= png_set_text_2(png_ptr
, info_ptr
, text_ptr
, 1);
2308 png_free(png_ptr
, png_ptr
->chunkdata
);
2309 png_ptr
->chunkdata
= NULL
;
2310 png_free(png_ptr
, text_ptr
);
2313 png_warning(png_ptr
, "Insufficient memory to process text chunk");
2317 #ifdef PNG_READ_zTXt_SUPPORTED
2318 /* Note: this does not correctly handle chunks that are > 64K under DOS */
2320 png_handle_zTXt(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
2326 png_size_t slength
, prefix_len
, data_len
;
2328 png_debug(1, "in png_handle_zTXt");
2330 #ifdef PNG_USER_LIMITS_SUPPORTED
2331 if (png_ptr
->user_chunk_cache_max
!= 0)
2333 if (png_ptr
->user_chunk_cache_max
== 1)
2335 png_crc_finish(png_ptr
, length
);
2339 if (--png_ptr
->user_chunk_cache_max
== 1)
2341 png_warning(png_ptr
, "No space in chunk cache for zTXt");
2342 png_crc_finish(png_ptr
, length
);
2348 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
2349 png_error(png_ptr
, "Missing IHDR before zTXt");
2351 if (png_ptr
->mode
& PNG_HAVE_IDAT
)
2352 png_ptr
->mode
|= PNG_AFTER_IDAT
;
2354 #ifdef PNG_MAX_MALLOC_64K
2355 /* We will no doubt have problems with chunks even half this size, but
2356 * there is no hard and fast rule to tell us where to stop.
2358 if (length
> (png_uint_32
)65535L)
2360 png_warning(png_ptr
, "zTXt chunk too large to fit in memory");
2361 png_crc_finish(png_ptr
, length
);
2366 png_free(png_ptr
, png_ptr
->chunkdata
);
2367 png_ptr
->chunkdata
= (png_charp
)png_malloc_warn(png_ptr
, length
+ 1);
2369 if (png_ptr
->chunkdata
== NULL
)
2371 png_warning(png_ptr
, "Out of memory processing zTXt chunk");
2376 png_crc_read(png_ptr
, (png_bytep
)png_ptr
->chunkdata
, slength
);
2378 if (png_crc_finish(png_ptr
, 0))
2380 png_free(png_ptr
, png_ptr
->chunkdata
);
2381 png_ptr
->chunkdata
= NULL
;
2385 png_ptr
->chunkdata
[slength
] = 0x00;
2387 for (text
= png_ptr
->chunkdata
; *text
; text
++)
2390 /* zTXt must have some text after the chunkdataword */
2391 if (text
>= png_ptr
->chunkdata
+ slength
- 2)
2393 png_warning(png_ptr
, "Truncated zTXt chunk");
2394 png_free(png_ptr
, png_ptr
->chunkdata
);
2395 png_ptr
->chunkdata
= NULL
;
2401 comp_type
= *(++text
);
2403 if (comp_type
!= PNG_TEXT_COMPRESSION_zTXt
)
2405 png_warning(png_ptr
, "Unknown compression type in zTXt chunk");
2406 comp_type
= PNG_TEXT_COMPRESSION_zTXt
;
2409 text
++; /* Skip the compression_method byte */
2412 prefix_len
= text
- png_ptr
->chunkdata
;
2414 png_decompress_chunk(png_ptr
, comp_type
,
2415 (png_size_t
)length
, prefix_len
, &data_len
);
2417 text_ptr
= (png_textp
)png_malloc_warn(png_ptr
,
2418 png_sizeof(png_text
));
2420 if (text_ptr
== NULL
)
2422 png_warning(png_ptr
, "Not enough memory to process zTXt chunk");
2423 png_free(png_ptr
, png_ptr
->chunkdata
);
2424 png_ptr
->chunkdata
= NULL
;
2428 text_ptr
->compression
= comp_type
;
2429 text_ptr
->key
= png_ptr
->chunkdata
;
2430 text_ptr
->lang
= NULL
;
2431 text_ptr
->lang_key
= NULL
;
2432 text_ptr
->itxt_length
= 0;
2433 text_ptr
->text
= png_ptr
->chunkdata
+ prefix_len
;
2434 text_ptr
->text_length
= data_len
;
2436 ret
= png_set_text_2(png_ptr
, info_ptr
, text_ptr
, 1);
2438 png_free(png_ptr
, text_ptr
);
2439 png_free(png_ptr
, png_ptr
->chunkdata
);
2440 png_ptr
->chunkdata
= NULL
;
2443 png_error(png_ptr
, "Insufficient memory to store zTXt chunk");
2447 #ifdef PNG_READ_iTXt_SUPPORTED
2448 /* Note: this does not correctly handle chunks that are > 64K under DOS */
2450 png_handle_iTXt(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
2453 png_charp key
, lang
, text
, lang_key
;
2457 png_size_t slength
, prefix_len
, data_len
;
2459 png_debug(1, "in png_handle_iTXt");
2461 #ifdef PNG_USER_LIMITS_SUPPORTED
2462 if (png_ptr
->user_chunk_cache_max
!= 0)
2464 if (png_ptr
->user_chunk_cache_max
== 1)
2466 png_crc_finish(png_ptr
, length
);
2470 if (--png_ptr
->user_chunk_cache_max
== 1)
2472 png_warning(png_ptr
, "No space in chunk cache for iTXt");
2473 png_crc_finish(png_ptr
, length
);
2479 if (!(png_ptr
->mode
& PNG_HAVE_IHDR
))
2480 png_error(png_ptr
, "Missing IHDR before iTXt");
2482 if (png_ptr
->mode
& PNG_HAVE_IDAT
)
2483 png_ptr
->mode
|= PNG_AFTER_IDAT
;
2485 #ifdef PNG_MAX_MALLOC_64K
2486 /* We will no doubt have problems with chunks even half this size, but
2487 * there is no hard and fast rule to tell us where to stop.
2489 if (length
> (png_uint_32
)65535L)
2491 png_warning(png_ptr
, "iTXt chunk too large to fit in memory");
2492 png_crc_finish(png_ptr
, length
);
2497 png_free(png_ptr
, png_ptr
->chunkdata
);
2498 png_ptr
->chunkdata
= (png_charp
)png_malloc_warn(png_ptr
, length
+ 1);
2500 if (png_ptr
->chunkdata
== NULL
)
2502 png_warning(png_ptr
, "No memory to process iTXt chunk");
2507 png_crc_read(png_ptr
, (png_bytep
)png_ptr
->chunkdata
, slength
);
2509 if (png_crc_finish(png_ptr
, 0))
2511 png_free(png_ptr
, png_ptr
->chunkdata
);
2512 png_ptr
->chunkdata
= NULL
;
2516 png_ptr
->chunkdata
[slength
] = 0x00;
2518 for (lang
= png_ptr
->chunkdata
; *lang
; lang
++)
2521 lang
++; /* Skip NUL separator */
2523 /* iTXt must have a language tag (possibly empty), two compression bytes,
2524 * translated keyword (possibly empty), and possibly some text after the
2528 if (lang
>= png_ptr
->chunkdata
+ slength
- 3)
2530 png_warning(png_ptr
, "Truncated iTXt chunk");
2531 png_free(png_ptr
, png_ptr
->chunkdata
);
2532 png_ptr
->chunkdata
= NULL
;
2536 comp_flag
= *lang
++;
2537 comp_type
= *lang
++;
2539 /* 1.5.14: The spec says "for uncompressed text decoders shall ignore [the
2540 * compression type]". The compression flag shall be 0 (no compression) or
2541 * 1 (compressed with method 0 - deflate.)
2543 if (comp_flag
!= 0 && comp_flag
!= 1)
2545 png_warning(png_ptr
, "invalid iTXt compression flag");
2546 png_free(png_ptr
, png_ptr
->chunkdata
);
2547 png_ptr
->chunkdata
= NULL
;
2551 if (comp_flag
/*compressed*/ && comp_type
!= 0)
2553 png_warning(png_ptr
, "unknown iTXt compression type");
2554 png_free(png_ptr
, png_ptr
->chunkdata
);
2555 png_ptr
->chunkdata
= NULL
;
2559 for (lang_key
= lang
; *lang_key
; lang_key
++)
2562 lang_key
++; /* Skip NUL separator */
2564 if (lang_key
>= png_ptr
->chunkdata
+ slength
)
2566 png_warning(png_ptr
, "Truncated iTXt chunk");
2567 png_free(png_ptr
, png_ptr
->chunkdata
);
2568 png_ptr
->chunkdata
= NULL
;
2572 for (text
= lang_key
; *text
; text
++)
2575 text
++; /* Skip NUL separator */
2577 if (text
>= png_ptr
->chunkdata
+ slength
)
2579 png_warning(png_ptr
, "Malformed iTXt chunk");
2580 png_free(png_ptr
, png_ptr
->chunkdata
);
2581 png_ptr
->chunkdata
= NULL
;
2585 prefix_len
= text
- png_ptr
->chunkdata
;
2587 key
=png_ptr
->chunkdata
;
2589 if (comp_flag
/*compressed*/)
2590 png_decompress_chunk(png_ptr
, comp_type
,
2591 (size_t)length
, prefix_len
, &data_len
);
2594 data_len
= png_strlen(png_ptr
->chunkdata
+ prefix_len
);
2596 text_ptr
= (png_textp
)png_malloc_warn(png_ptr
,
2597 png_sizeof(png_text
));
2599 if (text_ptr
== NULL
)
2601 png_warning(png_ptr
, "Not enough memory to process iTXt chunk");
2602 png_free(png_ptr
, png_ptr
->chunkdata
);
2603 png_ptr
->chunkdata
= NULL
;
2607 text_ptr
->compression
=
2608 (comp_flag
? PNG_ITXT_COMPRESSION_zTXt
: PNG_ITXT_COMPRESSION_NONE
);
2609 text_ptr
->lang_key
= png_ptr
->chunkdata
+ (lang_key
- key
);
2610 text_ptr
->lang
= png_ptr
->chunkdata
+ (lang
- key
);
2611 text_ptr
->itxt_length
= data_len
;
2612 text_ptr
->text_length
= 0;
2613 text_ptr
->key
= png_ptr
->chunkdata
;
2614 text_ptr
->text
= png_ptr
->chunkdata
+ prefix_len
;
2616 ret
= png_set_text_2(png_ptr
, info_ptr
, text_ptr
, 1);
2618 png_free(png_ptr
, text_ptr
);
2619 png_free(png_ptr
, png_ptr
->chunkdata
);
2620 png_ptr
->chunkdata
= NULL
;
2623 png_error(png_ptr
, "Insufficient memory to store iTXt chunk");
2627 /* This function is called when we haven't found a handler for a
2628 * chunk. If there isn't a problem with the chunk itself (ie bad
2629 * chunk name, CRC, or a critical chunk), the chunk is silently ignored
2630 * -- unless the PNG_FLAG_UNKNOWN_CHUNKS_SUPPORTED flag is on in which
2631 * case it will be saved away to be written out later.
2634 png_handle_unknown(png_structp png_ptr
, png_infop info_ptr
, png_uint_32 length
)
2636 png_uint_32 skip
= 0;
2638 png_debug(1, "in png_handle_unknown");
2640 #ifdef PNG_USER_LIMITS_SUPPORTED
2641 if (png_ptr
->user_chunk_cache_max
!= 0)
2643 if (png_ptr
->user_chunk_cache_max
== 1)
2645 png_crc_finish(png_ptr
, length
);
2649 if (--png_ptr
->user_chunk_cache_max
== 1)
2651 png_warning(png_ptr
, "No space in chunk cache for unknown chunk");
2652 png_crc_finish(png_ptr
, length
);
2658 if (png_ptr
->mode
& PNG_HAVE_IDAT
)
2660 if (png_ptr
->chunk_name
!= png_IDAT
)
2661 png_ptr
->mode
|= PNG_AFTER_IDAT
;
2664 if (PNG_CHUNK_CRITICAL(png_ptr
->chunk_name
))
2666 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
2667 if (png_chunk_unknown_handling(png_ptr
, png_ptr
->chunk_name
) !=
2668 PNG_HANDLE_CHUNK_ALWAYS
2669 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
2670 && png_ptr
->read_user_chunk_fn
== NULL
2674 png_chunk_error(png_ptr
, "unknown critical chunk");
2677 #ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
2678 if ((png_ptr
->flags
& PNG_FLAG_KEEP_UNKNOWN_CHUNKS
)
2679 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
2680 || (png_ptr
->read_user_chunk_fn
!= NULL
)
2684 #ifdef PNG_MAX_MALLOC_64K
2687 png_warning(png_ptr
, "unknown chunk too large to fit in memory");
2688 skip
= length
- 65535;
2693 /* TODO: this code is very close to the unknown handling in pngpread.c,
2694 * maybe it can be put into a common utility routine?
2695 * png_struct::unknown_chunk is just used as a temporary variable, along
2696 * with the data into which the chunk is read. These can be eliminated.
2698 PNG_CSTRING_FROM_CHUNK(png_ptr
->unknown_chunk
.name
, png_ptr
->chunk_name
);
2699 png_ptr
->unknown_chunk
.size
= (png_size_t
)length
;
2702 png_ptr
->unknown_chunk
.data
= NULL
;
2706 png_ptr
->unknown_chunk
.data
= (png_bytep
)png_malloc(png_ptr
, length
);
2707 png_crc_read(png_ptr
, png_ptr
->unknown_chunk
.data
, length
);
2710 #ifdef PNG_READ_USER_CHUNKS_SUPPORTED
2711 if (png_ptr
->read_user_chunk_fn
!= NULL
)
2713 /* Callback to user unknown chunk handler */
2716 ret
= (*(png_ptr
->read_user_chunk_fn
))
2717 (png_ptr
, &png_ptr
->unknown_chunk
);
2720 png_chunk_error(png_ptr
, "error in user chunk");
2724 if (PNG_CHUNK_CRITICAL(png_ptr
->chunk_name
))
2726 #ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED
2727 if (png_chunk_unknown_handling(png_ptr
, png_ptr
->chunk_name
) !=
2728 PNG_HANDLE_CHUNK_ALWAYS
)
2730 png_chunk_error(png_ptr
, "unknown critical chunk");
2733 png_set_unknown_chunks(png_ptr
, info_ptr
,
2734 &png_ptr
->unknown_chunk
, 1);
2740 png_set_unknown_chunks(png_ptr
, info_ptr
, &png_ptr
->unknown_chunk
, 1);
2742 png_free(png_ptr
, png_ptr
->unknown_chunk
.data
);
2743 png_ptr
->unknown_chunk
.data
= NULL
;
2750 png_crc_finish(png_ptr
, skip
);
2752 #ifndef PNG_READ_USER_CHUNKS_SUPPORTED
2753 PNG_UNUSED(info_ptr
) /* Quiet compiler warnings about unused info_ptr */
2757 /* This function is called to verify that a chunk name is valid.
2758 * This function can't have the "critical chunk check" incorporated
2759 * into it, since in the future we will need to be able to call user
2760 * functions to handle unknown critical chunks after we check that
2761 * the chunk name itself is valid.
2764 /* Bit hacking: the test for an invalid byte in the 4 byte chunk name is:
2766 * ((c) < 65 || (c) > 122 || ((c) > 90 && (c) < 97))
2770 png_check_chunk_name(png_structp png_ptr
, png_uint_32 chunk_name
)
2774 png_debug(1, "in png_check_chunk_name");
2776 for (i
=1; i
<=4; ++i
)
2778 int c
= chunk_name
& 0xff;
2780 if (c
< 65 || c
> 122 || (c
> 90 && c
< 97))
2781 png_chunk_error(png_ptr
, "invalid chunk type");
2787 /* Combines the row recently read in with the existing pixels in the row. This
2788 * routine takes care of alpha and transparency if requested. This routine also
2789 * handles the two methods of progressive display of interlaced images,
2790 * depending on the 'display' value; if 'display' is true then the whole row
2791 * (dp) is filled from the start by replicating the available pixels. If
2792 * 'display' is false only those pixels present in the pass are filled in.
2795 png_combine_row(png_structp png_ptr
, png_bytep dp
, int display
)
2797 unsigned int pixel_depth
= png_ptr
->transformed_pixel_depth
;
2798 png_const_bytep sp
= png_ptr
->row_buf
+ 1;
2799 png_uint_32 row_width
= png_ptr
->width
;
2800 unsigned int pass
= png_ptr
->pass
;
2801 png_bytep end_ptr
= 0;
2802 png_byte end_byte
= 0;
2803 unsigned int end_mask
;
2805 png_debug(1, "in png_combine_row");
2807 /* Added in 1.5.6: it should not be possible to enter this routine until at
2808 * least one row has been read from the PNG data and transformed.
2810 if (pixel_depth
== 0)
2811 png_error(png_ptr
, "internal row logic error");
2813 /* Added in 1.5.4: the pixel depth should match the information returned by
2814 * any call to png_read_update_info at this point. Do not continue if we got
2817 if (png_ptr
->info_rowbytes
!= 0 && png_ptr
->info_rowbytes
!=
2818 PNG_ROWBYTES(pixel_depth
, row_width
))
2819 png_error(png_ptr
, "internal row size calculation error");
2821 /* Don't expect this to ever happen: */
2823 png_error(png_ptr
, "internal row width error");
2825 /* Preserve the last byte in cases where only part of it will be overwritten,
2826 * the multiply below may overflow, we don't care because ANSI-C guarantees
2827 * we get the low bits.
2829 end_mask
= (pixel_depth
* row_width
) & 7;
2832 /* end_ptr == NULL is a flag to say do nothing */
2833 end_ptr
= dp
+ PNG_ROWBYTES(pixel_depth
, row_width
) - 1;
2834 end_byte
= *end_ptr
;
2835 # ifdef PNG_READ_PACKSWAP_SUPPORTED
2836 if (png_ptr
->transformations
& PNG_PACKSWAP
) /* little-endian byte */
2837 end_mask
= 0xff << end_mask
;
2839 else /* big-endian byte */
2841 end_mask
= 0xff >> end_mask
;
2842 /* end_mask is now the bits to *keep* from the destination row */
2845 /* For non-interlaced images this reduces to a png_memcpy(). A png_memcpy()
2846 * will also happen if interlacing isn't supported or if the application
2847 * does not call png_set_interlace_handling(). In the latter cases the
2848 * caller just gets a sequence of the unexpanded rows from each interlace
2851 #ifdef PNG_READ_INTERLACING_SUPPORTED
2852 if (png_ptr
->interlaced
&& (png_ptr
->transformations
& PNG_INTERLACE
) &&
2853 pass
< 6 && (display
== 0 ||
2854 /* The following copies everything for 'display' on passes 0, 2 and 4. */
2855 (display
== 1 && (pass
& 1) != 0)))
2857 /* Narrow images may have no bits in a pass; the caller should handle
2858 * this, but this test is cheap:
2860 if (row_width
<= PNG_PASS_START_COL(pass
))
2863 if (pixel_depth
< 8)
2865 /* For pixel depths up to 4 bpp the 8-pixel mask can be expanded to fit
2866 * into 32 bits, then a single loop over the bytes using the four byte
2867 * values in the 32-bit mask can be used. For the 'display' option the
2868 * expanded mask may also not require any masking within a byte. To
2869 * make this work the PACKSWAP option must be taken into account - it
2870 * simply requires the pixels to be reversed in each byte.
2872 * The 'regular' case requires a mask for each of the first 6 passes,
2873 * the 'display' case does a copy for the even passes in the range
2874 * 0..6. This has already been handled in the test above.
2876 * The masks are arranged as four bytes with the first byte to use in
2877 * the lowest bits (little-endian) regardless of the order (PACKSWAP or
2878 * not) of the pixels in each byte.
2880 * NOTE: the whole of this logic depends on the caller of this function
2881 * only calling it on rows appropriate to the pass. This function only
2882 * understands the 'x' logic; the 'y' logic is handled by the caller.
2884 * The following defines allow generation of compile time constant bit
2885 * masks for each pixel depth and each possibility of swapped or not
2886 * swapped bytes. Pass 'p' is in the range 0..6; 'x', a pixel index,
2887 * is in the range 0..7; and the result is 1 if the pixel is to be
2888 * copied in the pass, 0 if not. 'S' is for the sparkle method, 'B'
2889 * for the block method.
2891 * With some compilers a compile time expression of the general form:
2893 * (shift >= 32) ? (a >> (shift-32)) : (b >> shift)
2895 * Produces warnings with values of 'shift' in the range 33 to 63
2896 * because the right hand side of the ?: expression is evaluated by
2897 * the compiler even though it isn't used. Microsoft Visual C (various
2898 * versions) and the Intel C compiler are known to do this. To avoid
2899 * this the following macros are used in 1.5.6. This is a temporary
2900 * solution to avoid destabilizing the code during the release process.
2902 # if PNG_USE_COMPILE_TIME_MASKS
2903 # define PNG_LSR(x,s) ((x)>>((s) & 0x1f))
2904 # define PNG_LSL(x,s) ((x)<<((s) & 0x1f))
2906 # define PNG_LSR(x,s) ((x)>>(s))
2907 # define PNG_LSL(x,s) ((x)<<(s))
2909 # define S_COPY(p,x) (((p)<4 ? PNG_LSR(0x80088822,(3-(p))*8+(7-(x))) :\
2910 PNG_LSR(0xaa55ff00,(7-(p))*8+(7-(x)))) & 1)
2911 # define B_COPY(p,x) (((p)<4 ? PNG_LSR(0xff0fff33,(3-(p))*8+(7-(x))) :\
2912 PNG_LSR(0xff55ff00,(7-(p))*8+(7-(x)))) & 1)
2914 /* Return a mask for pass 'p' pixel 'x' at depth 'd'. The mask is
2915 * little endian - the first pixel is at bit 0 - however the extra
2916 * parameter 's' can be set to cause the mask position to be swapped
2917 * within each byte, to match the PNG format. This is done by XOR of
2918 * the shift with 7, 6 or 4 for bit depths 1, 2 and 4.
2920 # define PIXEL_MASK(p,x,d,s) \
2921 (PNG_LSL(((PNG_LSL(1U,(d)))-1),(((x)*(d))^((s)?8-(d):0))))
2923 /* Hence generate the appropriate 'block' or 'sparkle' pixel copy mask.
2925 # define S_MASKx(p,x,d,s) (S_COPY(p,x)?PIXEL_MASK(p,x,d,s):0)
2926 # define B_MASKx(p,x,d,s) (B_COPY(p,x)?PIXEL_MASK(p,x,d,s):0)
2928 /* Combine 8 of these to get the full mask. For the 1-bpp and 2-bpp
2929 * cases the result needs replicating, for the 4-bpp case the above
2930 * generates a full 32 bits.
2932 # define MASK_EXPAND(m,d) ((m)*((d)==1?0x01010101:((d)==2?0x00010001:1)))
2934 # define S_MASK(p,d,s) MASK_EXPAND(S_MASKx(p,0,d,s) + S_MASKx(p,1,d,s) +\
2935 S_MASKx(p,2,d,s) + S_MASKx(p,3,d,s) + S_MASKx(p,4,d,s) +\
2936 S_MASKx(p,5,d,s) + S_MASKx(p,6,d,s) + S_MASKx(p,7,d,s), d)
2938 # define B_MASK(p,d,s) MASK_EXPAND(B_MASKx(p,0,d,s) + B_MASKx(p,1,d,s) +\
2939 B_MASKx(p,2,d,s) + B_MASKx(p,3,d,s) + B_MASKx(p,4,d,s) +\
2940 B_MASKx(p,5,d,s) + B_MASKx(p,6,d,s) + B_MASKx(p,7,d,s), d)
2942 #if PNG_USE_COMPILE_TIME_MASKS
2943 /* Utility macros to construct all the masks for a depth/swap
2944 * combination. The 's' parameter says whether the format is PNG
2945 * (big endian bytes) or not. Only the three odd-numbered passes are
2946 * required for the display/block algorithm.
2948 # define S_MASKS(d,s) { S_MASK(0,d,s), S_MASK(1,d,s), S_MASK(2,d,s),\
2949 S_MASK(3,d,s), S_MASK(4,d,s), S_MASK(5,d,s) }
2951 # define B_MASKS(d,s) { B_MASK(1,d,s), S_MASK(3,d,s), S_MASK(5,d,s) }
2953 # define DEPTH_INDEX(d) ((d)==1?0:((d)==2?1:2))
2955 /* Hence the pre-compiled masks indexed by PACKSWAP (or not), depth and
2958 static PNG_CONST png_uint_32 row_mask
[2/*PACKSWAP*/][3/*depth*/][6] =
2960 /* Little-endian byte masks for PACKSWAP */
2961 { S_MASKS(1,0), S_MASKS(2,0), S_MASKS(4,0) },
2962 /* Normal (big-endian byte) masks - PNG format */
2963 { S_MASKS(1,1), S_MASKS(2,1), S_MASKS(4,1) }
2966 /* display_mask has only three entries for the odd passes, so index by
2969 static PNG_CONST png_uint_32 display_mask
[2][3][3] =
2971 /* Little-endian byte masks for PACKSWAP */
2972 { B_MASKS(1,0), B_MASKS(2,0), B_MASKS(4,0) },
2973 /* Normal (big-endian byte) masks - PNG format */
2974 { B_MASKS(1,1), B_MASKS(2,1), B_MASKS(4,1) }
2977 # define MASK(pass,depth,display,png)\
2978 ((display)?display_mask[png][DEPTH_INDEX(depth)][pass>>1]:\
2979 row_mask[png][DEPTH_INDEX(depth)][pass])
2981 #else /* !PNG_USE_COMPILE_TIME_MASKS */
2982 /* This is the runtime alternative: it seems unlikely that this will
2983 * ever be either smaller or faster than the compile time approach.
2985 # define MASK(pass,depth,display,png)\
2986 ((display)?B_MASK(pass,depth,png):S_MASK(pass,depth,png))
2987 #endif /* !PNG_USE_COMPILE_TIME_MASKS */
2989 /* Use the appropriate mask to copy the required bits. In some cases
2990 * the byte mask will be 0 or 0xff, optimize these cases. row_width is
2991 * the number of pixels, but the code copies bytes, so it is necessary
2992 * to special case the end.
2994 png_uint_32 pixels_per_byte
= 8 / pixel_depth
;
2997 # ifdef PNG_READ_PACKSWAP_SUPPORTED
2998 if (png_ptr
->transformations
& PNG_PACKSWAP
)
2999 mask
= MASK(pass
, pixel_depth
, display
, 0);
3003 mask
= MASK(pass
, pixel_depth
, display
, 1);
3009 /* It doesn't matter in the following if png_uint_32 has more than
3010 * 32 bits because the high bits always match those in m<<24; it is,
3011 * however, essential to use OR here, not +, because of this.
3014 mask
= (m
>> 8) | (m
<< 24); /* rotate right to good compilers */
3017 if (m
!= 0) /* something to copy */
3020 *dp
= (png_byte
)((*dp
& ~m
) | (*sp
& m
));
3025 /* NOTE: this may overwrite the last byte with garbage if the image
3026 * is not an exact number of bytes wide; libpng has always done
3029 if (row_width
<= pixels_per_byte
)
3030 break; /* May need to restore part of the last byte */
3032 row_width
-= pixels_per_byte
;
3038 else /* pixel_depth >= 8 */
3040 unsigned int bytes_to_copy
, bytes_to_jump
;
3042 /* Validate the depth - it must be a multiple of 8 */
3043 if (pixel_depth
& 7)
3044 png_error(png_ptr
, "invalid user transform pixel depth");
3046 pixel_depth
>>= 3; /* now in bytes */
3047 row_width
*= pixel_depth
;
3049 /* Regardless of pass number the Adam 7 interlace always results in a
3050 * fixed number of pixels to copy then to skip. There may be a
3051 * different number of pixels to skip at the start though.
3054 unsigned int offset
= PNG_PASS_START_COL(pass
) * pixel_depth
;
3056 row_width
-= offset
;
3061 /* Work out the bytes to copy. */
3064 /* When doing the 'block' algorithm the pixel in the pass gets
3065 * replicated to adjacent pixels. This is why the even (0,2,4,6)
3066 * passes are skipped above - the entire expanded row is copied.
3068 bytes_to_copy
= (1<<((6-pass
)>>1)) * pixel_depth
;
3070 /* But don't allow this number to exceed the actual row width. */
3071 if (bytes_to_copy
> row_width
)
3072 bytes_to_copy
= row_width
;
3075 else /* normal row; Adam7 only ever gives us one pixel to copy. */
3076 bytes_to_copy
= pixel_depth
;
3078 /* In Adam7 there is a constant offset between where the pixels go. */
3079 bytes_to_jump
= PNG_PASS_COL_OFFSET(pass
) * pixel_depth
;
3081 /* And simply copy these bytes. Some optimization is possible here,
3082 * depending on the value of 'bytes_to_copy'. Special case the low
3083 * byte counts, which we know to be frequent.
3085 * Notice that these cases all 'return' rather than 'break' - this
3086 * avoids an unnecessary test on whether to restore the last byte
3089 switch (bytes_to_copy
)
3096 if (row_width
<= bytes_to_jump
)
3099 dp
+= bytes_to_jump
;
3100 sp
+= bytes_to_jump
;
3101 row_width
-= bytes_to_jump
;
3105 /* There is a possibility of a partial copy at the end here; this
3106 * slows the code down somewhat.
3110 dp
[0] = sp
[0], dp
[1] = sp
[1];
3112 if (row_width
<= bytes_to_jump
)
3115 sp
+= bytes_to_jump
;
3116 dp
+= bytes_to_jump
;
3117 row_width
-= bytes_to_jump
;
3119 while (row_width
> 1);
3121 /* And there can only be one byte left at this point: */
3126 /* This can only be the RGB case, so each copy is exactly one
3127 * pixel and it is not necessary to check for a partial copy.
3131 dp
[0] = sp
[0], dp
[1] = sp
[1], dp
[2] = sp
[2];
3133 if (row_width
<= bytes_to_jump
)
3136 sp
+= bytes_to_jump
;
3137 dp
+= bytes_to_jump
;
3138 row_width
-= bytes_to_jump
;
3142 #if PNG_ALIGN_TYPE != PNG_ALIGN_NONE
3143 /* Check for double byte alignment and, if possible, use a
3144 * 16-bit copy. Don't attempt this for narrow images - ones that
3145 * are less than an interlace panel wide. Don't attempt it for
3146 * wide bytes_to_copy either - use the png_memcpy there.
3148 if (bytes_to_copy
< 16 /*else use png_memcpy*/ &&
3149 png_isaligned(dp
, png_uint_16
) &&
3150 png_isaligned(sp
, png_uint_16
) &&
3151 bytes_to_copy
% sizeof (png_uint_16
) == 0 &&
3152 bytes_to_jump
% sizeof (png_uint_16
) == 0)
3154 /* Everything is aligned for png_uint_16 copies, but try for
3155 * png_uint_32 first.
3157 if (png_isaligned(dp
, png_uint_32
) &&
3158 png_isaligned(sp
, png_uint_32
) &&
3159 bytes_to_copy
% sizeof (png_uint_32
) == 0 &&
3160 bytes_to_jump
% sizeof (png_uint_32
) == 0)
3162 png_uint_32p dp32
= (png_uint_32p
)dp
;
3163 png_const_uint_32p sp32
= (png_const_uint_32p
)sp
;
3164 unsigned int skip
= (bytes_to_jump
-bytes_to_copy
) /
3165 sizeof (png_uint_32
);
3169 size_t c
= bytes_to_copy
;
3173 c
-= sizeof (png_uint_32
);
3177 if (row_width
<= bytes_to_jump
)
3182 row_width
-= bytes_to_jump
;
3184 while (bytes_to_copy
<= row_width
);
3186 /* Get to here when the row_width truncates the final copy.
3187 * There will be 1-3 bytes left to copy, so don't try the
3188 * 16-bit loop below.
3190 dp
= (png_bytep
)dp32
;
3191 sp
= (png_const_bytep
)sp32
;
3194 while (--row_width
> 0);
3198 /* Else do it in 16-bit quantities, but only if the size is
3203 png_uint_16p dp16
= (png_uint_16p
)dp
;
3204 png_const_uint_16p sp16
= (png_const_uint_16p
)sp
;
3205 unsigned int skip
= (bytes_to_jump
-bytes_to_copy
) /
3206 sizeof (png_uint_16
);
3210 size_t c
= bytes_to_copy
;
3214 c
-= sizeof (png_uint_16
);
3218 if (row_width
<= bytes_to_jump
)
3223 row_width
-= bytes_to_jump
;
3225 while (bytes_to_copy
<= row_width
);
3227 /* End of row - 1 byte left, bytes_to_copy > row_width: */
3228 dp
= (png_bytep
)dp16
;
3229 sp
= (png_const_bytep
)sp16
;
3232 while (--row_width
> 0);
3236 #endif /* PNG_ALIGN_ code */
3238 /* The true default - use a png_memcpy: */
3241 png_memcpy(dp
, sp
, bytes_to_copy
);
3243 if (row_width
<= bytes_to_jump
)
3246 sp
+= bytes_to_jump
;
3247 dp
+= bytes_to_jump
;
3248 row_width
-= bytes_to_jump
;
3249 if (bytes_to_copy
> row_width
)
3250 bytes_to_copy
= row_width
;
3255 } /* pixel_depth >= 8 */
3257 /* Here if pixel_depth < 8 to check 'end_ptr' below. */
3262 /* If here then the switch above wasn't used so just png_memcpy the whole row
3263 * from the temporary row buffer (notice that this overwrites the end of the
3264 * destination row if it is a partial byte.)
3266 png_memcpy(dp
, sp
, PNG_ROWBYTES(pixel_depth
, row_width
));
3268 /* Restore the overwritten bits from the last byte if necessary. */
3269 if (end_ptr
!= NULL
)
3270 *end_ptr
= (png_byte
)((end_byte
& end_mask
) | (*end_ptr
& ~end_mask
));
3273 #ifdef PNG_READ_INTERLACING_SUPPORTED
3275 png_do_read_interlace(png_row_infop row_info
, png_bytep row
, int pass
,
3276 png_uint_32 transformations
/* Because these may affect the byte layout */)
3278 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
3279 /* Offset to next interlace block */
3280 static PNG_CONST
int png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
3282 png_debug(1, "in png_do_read_interlace");
3283 if (row
!= NULL
&& row_info
!= NULL
)
3285 png_uint_32 final_width
;
3287 final_width
= row_info
->width
* png_pass_inc
[pass
];
3289 switch (row_info
->pixel_depth
)
3293 png_bytep sp
= row
+ (png_size_t
)((row_info
->width
- 1) >> 3);
3294 png_bytep dp
= row
+ (png_size_t
)((final_width
- 1) >> 3);
3296 int s_start
, s_end
, s_inc
;
3297 int jstop
= png_pass_inc
[pass
];
3302 #ifdef PNG_READ_PACKSWAP_SUPPORTED
3303 if (transformations
& PNG_PACKSWAP
)
3305 sshift
= (int)((row_info
->width
+ 7) & 0x07);
3306 dshift
= (int)((final_width
+ 7) & 0x07);
3315 sshift
= 7 - (int)((row_info
->width
+ 7) & 0x07);
3316 dshift
= 7 - (int)((final_width
+ 7) & 0x07);
3322 for (i
= 0; i
< row_info
->width
; i
++)
3324 v
= (png_byte
)((*sp
>> sshift
) & 0x01);
3325 for (j
= 0; j
< jstop
; j
++)
3327 *dp
&= (png_byte
)((0x7f7f >> (7 - dshift
)) & 0xff);
3328 *dp
|= (png_byte
)(v
<< dshift
);
3330 if (dshift
== s_end
)
3340 if (sshift
== s_end
)
3354 png_bytep sp
= row
+ (png_uint_32
)((row_info
->width
- 1) >> 2);
3355 png_bytep dp
= row
+ (png_uint_32
)((final_width
- 1) >> 2);
3357 int s_start
, s_end
, s_inc
;
3358 int jstop
= png_pass_inc
[pass
];
3361 #ifdef PNG_READ_PACKSWAP_SUPPORTED
3362 if (transformations
& PNG_PACKSWAP
)
3364 sshift
= (int)(((row_info
->width
+ 3) & 0x03) << 1);
3365 dshift
= (int)(((final_width
+ 3) & 0x03) << 1);
3374 sshift
= (int)((3 - ((row_info
->width
+ 3) & 0x03)) << 1);
3375 dshift
= (int)((3 - ((final_width
+ 3) & 0x03)) << 1);
3381 for (i
= 0; i
< row_info
->width
; i
++)
3386 v
= (png_byte
)((*sp
>> sshift
) & 0x03);
3387 for (j
= 0; j
< jstop
; j
++)
3389 *dp
&= (png_byte
)((0x3f3f >> (6 - dshift
)) & 0xff);
3390 *dp
|= (png_byte
)(v
<< dshift
);
3392 if (dshift
== s_end
)
3402 if (sshift
== s_end
)
3416 png_bytep sp
= row
+ (png_size_t
)((row_info
->width
- 1) >> 1);
3417 png_bytep dp
= row
+ (png_size_t
)((final_width
- 1) >> 1);
3419 int s_start
, s_end
, s_inc
;
3421 int jstop
= png_pass_inc
[pass
];
3423 #ifdef PNG_READ_PACKSWAP_SUPPORTED
3424 if (transformations
& PNG_PACKSWAP
)
3426 sshift
= (int)(((row_info
->width
+ 1) & 0x01) << 2);
3427 dshift
= (int)(((final_width
+ 1) & 0x01) << 2);
3436 sshift
= (int)((1 - ((row_info
->width
+ 1) & 0x01)) << 2);
3437 dshift
= (int)((1 - ((final_width
+ 1) & 0x01)) << 2);
3443 for (i
= 0; i
< row_info
->width
; i
++)
3445 png_byte v
= (png_byte
)((*sp
>> sshift
) & 0x0f);
3448 for (j
= 0; j
< jstop
; j
++)
3450 *dp
&= (png_byte
)((0xf0f >> (4 - dshift
)) & 0xff);
3451 *dp
|= (png_byte
)(v
<< dshift
);
3453 if (dshift
== s_end
)
3463 if (sshift
== s_end
)
3477 png_size_t pixel_bytes
= (row_info
->pixel_depth
>> 3);
3479 png_bytep sp
= row
+ (png_size_t
)(row_info
->width
- 1)
3482 png_bytep dp
= row
+ (png_size_t
)(final_width
- 1) * pixel_bytes
;
3484 int jstop
= png_pass_inc
[pass
];
3487 for (i
= 0; i
< row_info
->width
; i
++)
3492 png_memcpy(v
, sp
, pixel_bytes
);
3494 for (j
= 0; j
< jstop
; j
++)
3496 png_memcpy(dp
, v
, pixel_bytes
);
3506 row_info
->width
= final_width
;
3507 row_info
->rowbytes
= PNG_ROWBYTES(row_info
->pixel_depth
, final_width
);
3509 #ifndef PNG_READ_PACKSWAP_SUPPORTED
3510 PNG_UNUSED(transformations
) /* Silence compiler warning */
3513 #endif /* PNG_READ_INTERLACING_SUPPORTED */
3516 png_read_filter_row_sub(png_row_infop row_info
, png_bytep row
,
3517 png_const_bytep prev_row
)
3520 png_size_t istop
= row_info
->rowbytes
;
3521 unsigned int bpp
= (row_info
->pixel_depth
+ 7) >> 3;
3522 png_bytep rp
= row
+ bpp
;
3524 PNG_UNUSED(prev_row
)
3526 for (i
= bpp
; i
< istop
; i
++)
3528 *rp
= (png_byte
)(((int)(*rp
) + (int)(*(rp
-bpp
))) & 0xff);
3534 png_read_filter_row_up(png_row_infop row_info
, png_bytep row
,
3535 png_const_bytep prev_row
)
3538 png_size_t istop
= row_info
->rowbytes
;
3540 png_const_bytep pp
= prev_row
;
3542 for (i
= 0; i
< istop
; i
++)
3544 *rp
= (png_byte
)(((int)(*rp
) + (int)(*pp
++)) & 0xff);
3550 png_read_filter_row_avg(png_row_infop row_info
, png_bytep row
,
3551 png_const_bytep prev_row
)
3555 png_const_bytep pp
= prev_row
;
3556 unsigned int bpp
= (row_info
->pixel_depth
+ 7) >> 3;
3557 png_size_t istop
= row_info
->rowbytes
- bpp
;
3559 for (i
= 0; i
< bpp
; i
++)
3561 *rp
= (png_byte
)(((int)(*rp
) +
3562 ((int)(*pp
++) / 2 )) & 0xff);
3567 for (i
= 0; i
< istop
; i
++)
3569 *rp
= (png_byte
)(((int)(*rp
) +
3570 (int)(*pp
++ + *(rp
-bpp
)) / 2 ) & 0xff);
3577 png_read_filter_row_paeth_1byte_pixel(png_row_infop row_info
, png_bytep row
,
3578 png_const_bytep prev_row
)
3580 png_bytep rp_end
= row
+ row_info
->rowbytes
;
3583 /* First pixel/byte */
3586 *row
++ = (png_byte
)a
;
3589 while (row
< rp_end
)
3591 int b
, pa
, pb
, pc
, p
;
3593 a
&= 0xff; /* From previous iteration or start */
3604 pa
= p
< 0 ? -p
: p
;
3605 pb
= pc
< 0 ? -pc
: pc
;
3606 pc
= (p
+ pc
) < 0 ? -(p
+ pc
) : p
+ pc
;
3609 /* Find the best predictor, the least of pa, pb, pc favoring the earlier
3610 * ones in the case of a tie.
3612 if (pb
< pa
) pa
= pb
, a
= b
;
3615 /* Calculate the current pixel in a, and move the previous row pixel to c
3616 * for the next time round the loop
3620 *row
++ = (png_byte
)a
;
3625 png_read_filter_row_paeth_multibyte_pixel(png_row_infop row_info
, png_bytep row
,
3626 png_const_bytep prev_row
)
3628 int bpp
= (row_info
->pixel_depth
+ 7) >> 3;
3629 png_bytep rp_end
= row
+ bpp
;
3631 /* Process the first pixel in the row completely (this is the same as 'up'
3632 * because there is only one candidate predictor for the first row).
3634 while (row
< rp_end
)
3636 int a
= *row
+ *prev_row
++;
3637 *row
++ = (png_byte
)a
;
3641 rp_end
+= row_info
->rowbytes
- bpp
;
3643 while (row
< rp_end
)
3645 int a
, b
, c
, pa
, pb
, pc
, p
;
3647 c
= *(prev_row
- bpp
);
3659 pa
= p
< 0 ? -p
: p
;
3660 pb
= pc
< 0 ? -pc
: pc
;
3661 pc
= (p
+ pc
) < 0 ? -(p
+ pc
) : p
+ pc
;
3664 if (pb
< pa
) pa
= pb
, a
= b
;
3669 *row
++ = (png_byte
)a
;
3674 png_init_filter_functions(png_structp pp
)
3676 unsigned int bpp
= (pp
->pixel_depth
+ 7) >> 3;
3678 pp
->read_filter
[PNG_FILTER_VALUE_SUB
-1] = png_read_filter_row_sub
;
3679 pp
->read_filter
[PNG_FILTER_VALUE_UP
-1] = png_read_filter_row_up
;
3680 pp
->read_filter
[PNG_FILTER_VALUE_AVG
-1] = png_read_filter_row_avg
;
3682 pp
->read_filter
[PNG_FILTER_VALUE_PAETH
-1] =
3683 png_read_filter_row_paeth_1byte_pixel
;
3685 pp
->read_filter
[PNG_FILTER_VALUE_PAETH
-1] =
3686 png_read_filter_row_paeth_multibyte_pixel
;
3688 #ifdef PNG_FILTER_OPTIMIZATIONS
3689 /* To use this define PNG_FILTER_OPTIMIZATIONS as the name of a function to
3690 * call to install hardware optimizations for the above functions; simply
3691 * replace whatever elements of the pp->read_filter[] array with a hardware
3692 * specific (or, for that matter, generic) optimization.
3694 * To see an example of this examine what configure.ac does when
3695 * --enable-arm-neon is specified on the command line.
3697 PNG_FILTER_OPTIMIZATIONS(pp
, bpp
);
3702 png_read_filter_row(png_structp pp
, png_row_infop row_info
, png_bytep row
,
3703 png_const_bytep prev_row
, int filter
)
3705 if (pp
->read_filter
[0] == NULL
)
3706 png_init_filter_functions(pp
);
3707 if (filter
> PNG_FILTER_VALUE_NONE
&& filter
< PNG_FILTER_VALUE_LAST
)
3708 pp
->read_filter
[filter
-1](row_info
, row
, prev_row
);
3711 #ifdef PNG_SEQUENTIAL_READ_SUPPORTED
3713 png_read_finish_row(png_structp png_ptr
)
3715 #ifdef PNG_READ_INTERLACING_SUPPORTED
3716 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
3718 /* Start of interlace block */
3719 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
3721 /* Offset to next interlace block */
3722 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
3724 /* Start of interlace block in the y direction */
3725 static PNG_CONST png_byte png_pass_ystart
[7] = {0, 0, 4, 0, 2, 0, 1};
3727 /* Offset to next interlace block in the y direction */
3728 static PNG_CONST png_byte png_pass_yinc
[7] = {8, 8, 8, 4, 4, 2, 2};
3729 #endif /* PNG_READ_INTERLACING_SUPPORTED */
3731 png_debug(1, "in png_read_finish_row");
3732 png_ptr
->row_number
++;
3733 if (png_ptr
->row_number
< png_ptr
->num_rows
)
3736 #ifdef PNG_READ_INTERLACING_SUPPORTED
3737 if (png_ptr
->interlaced
)
3739 png_ptr
->row_number
= 0;
3741 /* TO DO: don't do this if prev_row isn't needed (requires
3742 * read-ahead of the next row's filter byte.
3744 png_memset(png_ptr
->prev_row
, 0, png_ptr
->rowbytes
+ 1);
3750 if (png_ptr
->pass
>= 7)
3753 png_ptr
->iwidth
= (png_ptr
->width
+
3754 png_pass_inc
[png_ptr
->pass
] - 1 -
3755 png_pass_start
[png_ptr
->pass
]) /
3756 png_pass_inc
[png_ptr
->pass
];
3758 if (!(png_ptr
->transformations
& PNG_INTERLACE
))
3760 png_ptr
->num_rows
= (png_ptr
->height
+
3761 png_pass_yinc
[png_ptr
->pass
] - 1 -
3762 png_pass_ystart
[png_ptr
->pass
]) /
3763 png_pass_yinc
[png_ptr
->pass
];
3766 else /* if (png_ptr->transformations & PNG_INTERLACE) */
3767 break; /* libpng deinterlacing sees every row */
3769 } while (png_ptr
->num_rows
== 0 || png_ptr
->iwidth
== 0);
3771 if (png_ptr
->pass
< 7)
3774 #endif /* PNG_READ_INTERLACING_SUPPORTED */
3776 if (!(png_ptr
->flags
& PNG_FLAG_ZLIB_FINISHED
))
3781 png_ptr
->zstream
.next_out
= (Byte
*)&extra
;
3782 png_ptr
->zstream
.avail_out
= (uInt
)1;
3786 if (!(png_ptr
->zstream
.avail_in
))
3788 while (!png_ptr
->idat_size
)
3790 png_crc_finish(png_ptr
, 0);
3791 png_ptr
->idat_size
= png_read_chunk_header(png_ptr
);
3792 if (png_ptr
->chunk_name
!= png_IDAT
)
3793 png_error(png_ptr
, "Not enough image data");
3796 png_ptr
->zstream
.avail_in
= (uInt
)png_ptr
->zbuf_size
;
3797 png_ptr
->zstream
.next_in
= png_ptr
->zbuf
;
3799 if (png_ptr
->zbuf_size
> png_ptr
->idat_size
)
3800 png_ptr
->zstream
.avail_in
= (uInt
)png_ptr
->idat_size
;
3802 png_crc_read(png_ptr
, png_ptr
->zbuf
, png_ptr
->zstream
.avail_in
);
3803 png_ptr
->idat_size
-= png_ptr
->zstream
.avail_in
;
3806 ret
= inflate(&png_ptr
->zstream
, Z_PARTIAL_FLUSH
);
3808 if (ret
== Z_STREAM_END
)
3810 if (!(png_ptr
->zstream
.avail_out
) || png_ptr
->zstream
.avail_in
||
3812 png_warning(png_ptr
, "Extra compressed data");
3814 png_ptr
->mode
|= PNG_AFTER_IDAT
;
3815 png_ptr
->flags
|= PNG_FLAG_ZLIB_FINISHED
;
3820 png_error(png_ptr
, png_ptr
->zstream
.msg
? png_ptr
->zstream
.msg
:
3821 "Decompression Error");
3823 if (!(png_ptr
->zstream
.avail_out
))
3825 png_warning(png_ptr
, "Extra compressed data");
3826 png_ptr
->mode
|= PNG_AFTER_IDAT
;
3827 png_ptr
->flags
|= PNG_FLAG_ZLIB_FINISHED
;
3832 png_ptr
->zstream
.avail_out
= 0;
3835 if (png_ptr
->idat_size
|| png_ptr
->zstream
.avail_in
)
3836 png_warning(png_ptr
, "Extra compression data");
3838 inflateReset(&png_ptr
->zstream
);
3840 png_ptr
->mode
|= PNG_AFTER_IDAT
;
3842 #endif /* PNG_SEQUENTIAL_READ_SUPPORTED */
3845 png_read_start_row(png_structp png_ptr
)
3847 #ifdef PNG_READ_INTERLACING_SUPPORTED
3848 /* Arrays to facilitate easy interlacing - use pass (0 - 6) as index */
3850 /* Start of interlace block */
3851 static PNG_CONST png_byte png_pass_start
[7] = {0, 4, 0, 2, 0, 1, 0};
3853 /* Offset to next interlace block */
3854 static PNG_CONST png_byte png_pass_inc
[7] = {8, 8, 4, 4, 2, 2, 1};
3856 /* Start of interlace block in the y direction */
3857 static PNG_CONST png_byte png_pass_ystart
[7] = {0, 0, 4, 0, 2, 0, 1};
3859 /* Offset to next interlace block in the y direction */
3860 static PNG_CONST png_byte png_pass_yinc
[7] = {8, 8, 8, 4, 4, 2, 2};
3863 int max_pixel_depth
;
3864 png_size_t row_bytes
;
3866 png_debug(1, "in png_read_start_row");
3867 png_ptr
->zstream
.avail_in
= 0;
3868 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
3869 png_init_read_transformations(png_ptr
);
3871 #ifdef PNG_READ_INTERLACING_SUPPORTED
3872 if (png_ptr
->interlaced
)
3874 if (!(png_ptr
->transformations
& PNG_INTERLACE
))
3875 png_ptr
->num_rows
= (png_ptr
->height
+ png_pass_yinc
[0] - 1 -
3876 png_pass_ystart
[0]) / png_pass_yinc
[0];
3879 png_ptr
->num_rows
= png_ptr
->height
;
3881 png_ptr
->iwidth
= (png_ptr
->width
+
3882 png_pass_inc
[png_ptr
->pass
] - 1 -
3883 png_pass_start
[png_ptr
->pass
]) /
3884 png_pass_inc
[png_ptr
->pass
];
3888 #endif /* PNG_READ_INTERLACING_SUPPORTED */
3890 png_ptr
->num_rows
= png_ptr
->height
;
3891 png_ptr
->iwidth
= png_ptr
->width
;
3894 max_pixel_depth
= png_ptr
->pixel_depth
;
3896 /* WARNING: * png_read_transform_info (pngrtran.c) performs a simpliar set of
3897 * calculations to calculate the final pixel depth, then
3898 * png_do_read_transforms actually does the transforms. This means that the
3899 * code which effectively calculates this value is actually repeated in three
3900 * separate places. They must all match. Innocent changes to the order of
3901 * transformations can and will break libpng in a way that causes memory
3906 #ifdef PNG_READ_PACK_SUPPORTED
3907 if ((png_ptr
->transformations
& PNG_PACK
) && png_ptr
->bit_depth
< 8)
3908 max_pixel_depth
= 8;
3911 #ifdef PNG_READ_EXPAND_SUPPORTED
3912 if (png_ptr
->transformations
& PNG_EXPAND
)
3914 if (png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
3916 if (png_ptr
->num_trans
)
3917 max_pixel_depth
= 32;
3920 max_pixel_depth
= 24;
3923 else if (png_ptr
->color_type
== PNG_COLOR_TYPE_GRAY
)
3925 if (max_pixel_depth
< 8)
3926 max_pixel_depth
= 8;
3928 if (png_ptr
->num_trans
)
3929 max_pixel_depth
*= 2;
3932 else if (png_ptr
->color_type
== PNG_COLOR_TYPE_RGB
)
3934 if (png_ptr
->num_trans
)
3936 max_pixel_depth
*= 4;
3937 max_pixel_depth
/= 3;
3943 #ifdef PNG_READ_EXPAND_16_SUPPORTED
3944 if (png_ptr
->transformations
& PNG_EXPAND_16
)
3946 # ifdef PNG_READ_EXPAND_SUPPORTED
3947 /* In fact it is an error if it isn't supported, but checking is
3950 if (png_ptr
->transformations
& PNG_EXPAND
)
3952 if (png_ptr
->bit_depth
< 16)
3953 max_pixel_depth
*= 2;
3957 png_ptr
->transformations
&= ~PNG_EXPAND_16
;
3961 #ifdef PNG_READ_FILLER_SUPPORTED
3962 if (png_ptr
->transformations
& (PNG_FILLER
))
3964 if (png_ptr
->color_type
== PNG_COLOR_TYPE_GRAY
)
3966 if (max_pixel_depth
<= 8)
3967 max_pixel_depth
= 16;
3970 max_pixel_depth
= 32;
3973 else if (png_ptr
->color_type
== PNG_COLOR_TYPE_RGB
||
3974 png_ptr
->color_type
== PNG_COLOR_TYPE_PALETTE
)
3976 if (max_pixel_depth
<= 32)
3977 max_pixel_depth
= 32;
3980 max_pixel_depth
= 64;
3985 #ifdef PNG_READ_GRAY_TO_RGB_SUPPORTED
3986 if (png_ptr
->transformations
& PNG_GRAY_TO_RGB
)
3989 #ifdef PNG_READ_EXPAND_SUPPORTED
3990 (png_ptr
->num_trans
&& (png_ptr
->transformations
& PNG_EXPAND
)) ||
3992 #ifdef PNG_READ_FILLER_SUPPORTED
3993 (png_ptr
->transformations
& (PNG_FILLER
)) ||
3995 png_ptr
->color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
3997 if (max_pixel_depth
<= 16)
3998 max_pixel_depth
= 32;
4001 max_pixel_depth
= 64;
4006 if (max_pixel_depth
<= 8)
4008 if (png_ptr
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
)
4009 max_pixel_depth
= 32;
4012 max_pixel_depth
= 24;
4015 else if (png_ptr
->color_type
== PNG_COLOR_TYPE_RGB_ALPHA
)
4016 max_pixel_depth
= 64;
4019 max_pixel_depth
= 48;
4024 #if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) && \
4025 defined(PNG_USER_TRANSFORM_PTR_SUPPORTED)
4026 if (png_ptr
->transformations
& PNG_USER_TRANSFORM
)
4028 int user_pixel_depth
= png_ptr
->user_transform_depth
*
4029 png_ptr
->user_transform_channels
;
4031 if (user_pixel_depth
> max_pixel_depth
)
4032 max_pixel_depth
= user_pixel_depth
;
4036 /* This value is stored in png_struct and double checked in the row read
4039 png_ptr
->maximum_pixel_depth
= (png_byte
)max_pixel_depth
;
4040 png_ptr
->transformed_pixel_depth
= 0; /* calculated on demand */
4042 /* Align the width on the next larger 8 pixels. Mainly used
4045 row_bytes
= ((png_ptr
->width
+ 7) & ~((png_uint_32
)7));
4046 /* Calculate the maximum bytes needed, adding a byte and a pixel
4049 row_bytes
= PNG_ROWBYTES(max_pixel_depth
, row_bytes
) +
4050 1 + ((max_pixel_depth
+ 7) >> 3);
4052 #ifdef PNG_MAX_MALLOC_64K
4053 if (row_bytes
> (png_uint_32
)65536L)
4054 png_error(png_ptr
, "This image requires a row greater than 64KB");
4057 if (row_bytes
+ 48 > png_ptr
->old_big_row_buf_size
)
4059 png_free(png_ptr
, png_ptr
->big_row_buf
);
4060 png_free(png_ptr
, png_ptr
->big_prev_row
);
4062 if (png_ptr
->interlaced
)
4063 png_ptr
->big_row_buf
= (png_bytep
)png_calloc(png_ptr
,
4067 png_ptr
->big_row_buf
= (png_bytep
)png_malloc(png_ptr
, row_bytes
+ 48);
4069 png_ptr
->big_prev_row
= (png_bytep
)png_malloc(png_ptr
, row_bytes
+ 48);
4071 #ifdef PNG_ALIGNED_MEMORY_SUPPORTED
4072 /* Use 16-byte aligned memory for row_buf with at least 16 bytes
4073 * of padding before and after row_buf; treat prev_row similarly.
4074 * NOTE: the alignment is to the start of the pixels, one beyond the start
4075 * of the buffer, because of the filter byte. Prior to libpng 1.5.6 this
4076 * was incorrect; the filter byte was aligned, which had the exact
4077 * opposite effect of that intended.
4080 png_bytep temp
= png_ptr
->big_row_buf
+ 32;
4081 int extra
= (int)((temp
- (png_bytep
)0) & 0x0f);
4082 png_ptr
->row_buf
= temp
- extra
- 1/*filter byte*/;
4084 temp
= png_ptr
->big_prev_row
+ 32;
4085 extra
= (int)((temp
- (png_bytep
)0) & 0x0f);
4086 png_ptr
->prev_row
= temp
- extra
- 1/*filter byte*/;
4090 /* Use 31 bytes of padding before and 17 bytes after row_buf. */
4091 png_ptr
->row_buf
= png_ptr
->big_row_buf
+ 31;
4092 png_ptr
->prev_row
= png_ptr
->big_prev_row
+ 31;
4094 png_ptr
->old_big_row_buf_size
= row_bytes
+ 48;
4097 #ifdef PNG_MAX_MALLOC_64K
4098 if (png_ptr
->rowbytes
> 65535)
4099 png_error(png_ptr
, "This image requires a row greater than 64KB");
4102 if (png_ptr
->rowbytes
> (PNG_SIZE_MAX
- 1))
4103 png_error(png_ptr
, "Row has too many bytes to allocate in memory");
4105 png_memset(png_ptr
->prev_row
, 0, png_ptr
->rowbytes
+ 1);
4107 png_debug1(3, "width = %u,", png_ptr
->width
);
4108 png_debug1(3, "height = %u,", png_ptr
->height
);
4109 png_debug1(3, "iwidth = %u,", png_ptr
->iwidth
);
4110 png_debug1(3, "num_rows = %u,", png_ptr
->num_rows
);
4111 png_debug1(3, "rowbytes = %lu,", (unsigned long)png_ptr
->rowbytes
);
4112 png_debug1(3, "irowbytes = %lu",
4113 (unsigned long)PNG_ROWBYTES(png_ptr
->pixel_depth
, png_ptr
->iwidth
) + 1);
4115 png_ptr
->flags
|= PNG_FLAG_ROW_INIT
;
4117 #endif /* PNG_READ_SUPPORTED */